hmgr 0.0.29 → 0.0.34

package/dist/adapter/claude-code.js

@@ -3,33 +3,23 @@ import spawn from 'cross-spawn';
 import { realpathSync } from 'node:fs';
 import { readFile, stat } from 'node:fs/promises';
 import path from 'node:path';
-import { ArbeitsverzeichnisOhneCliZugriff, HeimOhneCliZugriff, McpAbweichenderEintrag, McpNichtInGeteilterDatei, McpNurGeteilterFundort, McpUebernahmeNichtMoeglich, McpUebernahmeUnvollstaendig, OrtNichtUnterstuetzt, pluginSchluessel, wslUncZerlegen, } from "../kern/modell.js";
+import { ClaudeCliNichtErreichbar, McpAbweichenderEintrag, McpNichtInGeteilterDatei, McpNurGeteilterFundort, McpUebernahmeNichtMoeglich, McpUebernahmeUnvollstaendig, OrtNichtUnterstuetzt, pluginSchluessel, wslDistroVonOrt, wslUncZerlegen, } from "../kern/modell.js";
 import { ohneBom } from "./datei-text.js";
 import { LokalerZugriff } from "./dateisystem.js";
 import { gitignoreEintragen, istGitRepo } from "./gitignore.js";
 import { arbeitsverzeichnisVerbinden, heimVerbinden, nurHome } from "./heime.js";
 import { tiefGleich } from "./vergleich.js";
+import { WslBruecke, wslAusfuehrerMit, wslClaudeAusfuehrer } from "./wsl.js";
 import { mitZeitlimit } from "./zeitlimit.js";
 const CLAUDE_VERZEICHNIS = '.claude';
 const SKILLS_ORDNER = 'skills';
-/**
- * Die Adresse eines zusätzlichen Homedirs an diesem Ort (E78), sonst `undefined`. Was die
- * claude-CLI angeht — MCP-Server, Plugins —, gilt nur für das primäre Homedir: die CLI auf diesem
- * Rechner kennt die Konfiguration einer WSL-Distro nicht.
- */
-function zusaetzlichesHeim(ort) {
-    return ort.art === 'home' ? ort.heim : undefined;
+/** Der Pfad eines Arbeitsverzeichnisses in der Welt seiner CLI: in WSL der Linux-Pfad (E100). */
+function cliPfad(pfad) {
+    return wslUncZerlegen(pfad)?.linuxPfad ?? pfad;
 }
-/**
- * MCP und Plugins gehen nur über die claude-CLI dieses Rechners (E61, E78, E96): ein zusätzliches
- * Homedir und ein Arbeitsverzeichnis in WSL liegen außerhalb ihrer Konfiguration.
- */
-function ohneCliZugriffPruefen(harness, ort, was) {
-    const heim = zusaetzlichesHeim(ort);
-    if (heim !== undefined)
-        throw new HeimOhneCliZugriff(harness, heim, was);
-    if (ort.art === 'arbeitsverzeichnis' && wslUncZerlegen(ort.pfad) !== undefined)
-        throw new ArbeitsverzeichnisOhneCliZugriff(harness, ort.pfad, was);
+/** Der Ort, unter dem `ClaudeCode` die claude-CLI einer Distro anspricht: ihr Heim. */
+function distroOrt(distro) {
+    return { art: 'home', heim: `wsl:${distro}` };
 }
 const GITIGNORE_ZEILE = '.claude/';
 /**
@@ -60,6 +50,21 @@ export const claudeAusfuehrer = (args, cwd) => new Promise((aufloesen) => {
     kind.on('error', (fehler) => aufloesen({ stdout: fehler.message, code: 1 }));
     kind.on('close', (code) => aufloesen({ stdout: code === 0 ? stdout : `${stdout}${stderr}`, code: code ?? 1 }));
 });
+/**
+ * Pfadvergleich für E102: abschließende Trenner zählen nicht; bei Windows-Pfaden (Laufwerk oder
+ * UNC) sind außerdem `\\` und `/` sowie Groß-/Kleinschreibung gleich.
+ */
+export function pfadGleich(a, b) {
+    const windows = (p) => /^[a-zA-Z]:[\\/]/.test(p) || p.startsWith('\\\\');
+    const norm = (p, win) => {
+        let t = win ? p.replaceAll('\\', '/').toLowerCase() : p;
+        while (t.length > 1 && t.endsWith('/'))
+            t = t.slice(0, -1);
+        return t;
+    };
+    const win = windows(a) || windows(b);
+    return norm(a, win) === norm(b, win);
+}
 export class PluginListeUnbekannteForm extends Error {
     constructor(text) {
         super(`claude plugin list --json: ${text}`);
@@ -96,7 +101,13 @@ export function pluginListeLesen(text) {
         const scope = o['scope'];
         if (!istScope(scope))
             throw new PluginListeUnbekannteForm(`„${id}" hat keinen bekannten Scope`);
-        return { name: id.slice(0, trenner), marketplace: id.slice(trenner + 1), scope };
+        const projectPath = o['projectPath'];
+        return {
+            name: id.slice(0, trenner),
+            marketplace: id.slice(trenner + 1),
+            scope,
+            ...(typeof projectPath === 'string' ? { projectPath } : {}),
+        };
     });
 }
 /**
@@ -116,16 +127,25 @@ export function marketplaceListeLesen(text) {
 /**
  * Plugins über `claude plugin …`. Scope ist immer `local` mit dem Arbeitsverzeichnis selbst als
  * cwd (E27). Nur das Home des Nutzers läuft als `--scope user` ohne cwd.
+ *
+ * Welche claude-CLI, entscheidet der Ort (E101, derselbe Weg wie MCP seit E100): ein WSL-Heim und
+ * ein Arbeitsverzeichnis unter `\\wsl$` gehen an die CLI der Distro, das cwd ist dort der
+ * Linux-Pfad. Jede Installation führt ihre eigene Marketplace-Liste, deshalb wirken auch die
+ * Marketplace-Operationen in der Welt des genannten Orts. Vor jedem Aufruf prüft die Fähigkeit, ob
+ * dort eine CLI antwortet, sonst `ClaudeCliNichtErreichbar`.
  */
 class ClaudePlugins {
     harness;
-    ausfuehrer;
-    constructor(harness, ausfuehrer) {
+    constructor(harness) {
         this.harness = harness;
-        this.ausfuehrer = ausfuehrer;
     }
-    async rufen(args, cwd) {
-        const { stdout, code } = await this.ausfuehrer(args, cwd);
+    /** Die claude-CLI des Orts, nachdem feststeht, dass sie antwortet. */
+    async cli(ort) {
+        await this.harness.cliPruefen(ort);
+        return this.harness.ausfuehrerFuer(ort);
+    }
+    async rufen(ort, args, cwd) {
+        const { stdout, code } = await (await this.cli(ort))(args, cwd);
         if (code !== 0)
             throw new Error(`claude ${args.join(' ')} scheiterte (Code ${code}): ${stdout.trim()}`);
         return stdout;
@@ -134,48 +154,80 @@ class ClaudePlugins {
      * Scope und cwd eines Ortes (E27). Das cwd ist das Arbeitsverzeichnis selbst, nicht sein
      * Zielverzeichnis: außerhalb eines Git-Repos legt Claude Code die `settings.local.json` im
      * Startverzeichnis ab, mit dem Zielverzeichnis als cwd landete sie unter `.claude/skills/`.
+     * In WSL steht das cwd als Linux-Pfad da (E101).
      */
     scope(ziel) {
-        ohneCliZugriffPruefen(this.harness.name, ziel.ort, 'Plugins');
         if (ziel.ort.art === 'home')
             return { scope: 'user' };
         if (ziel.ort.art === 'arbeitsverzeichnis')
-            return { scope: 'local', cwd: ziel.ort.pfad };
+            return { scope: 'local', cwd: cliPfad(ziel.ort.pfad) };
         throw new OrtNichtUnterstuetzt(this.harness.name, ziel.ort.art);
     }
-    async marketplaceBekannt(name) {
-        const { stdout, code } = await this.ausfuehrer(['plugin', 'marketplace', 'list']);
+    async marketplaceBekannt(name, ort) {
+        const { stdout, code } = await (await this.cli(ort))(['plugin', 'marketplace', 'list']);
         if (code !== 0)
             return false;
         return marketplaceListeLesen(stdout).includes(name);
     }
-    async marketplaceHinzufuegen(_name, url) {
-        await this.rufen(['plugin', 'marketplace', 'add', url]);
+    /**
+     * Eine lokale Quelle steht mit ihrem Windows-Pfad da; die CLI einer Distro braucht ihn in deren
+     * Schreibweise (E101): `C:\…` unter der Automount-Wurzel, `\\wsl$\<dieselbe Distro>\…` als
+     * Linux-Pfad. URLs und alles andere gehen unverändert durch.
+     */
+    async marketplaceHinzufuegen(_name, url, ort) {
+        await this.rufen(ort, ['plugin', 'marketplace', 'add', await this.urlInWelt(url, ort)]);
+    }
+    async urlInWelt(url, ort) {
+        const distro = wslDistroVonOrt(ort);
+        if (distro === undefined)
+            return url;
+        const unc = wslUncZerlegen(url);
+        if (unc !== undefined)
+            return unc.distro.toLowerCase() === distro.toLowerCase() ? unc.linuxPfad : url;
+        if (/^[a-zA-Z]:[\\/]/.test(url))
+            return await this.harness.bruecke(distro).vomHost(url);
+        return url;
     }
     async installieren(plugin, marketplace, ziel) {
         const { scope, cwd } = this.scope(ziel);
-        await this.rufen(['plugin', 'install', pluginSchluessel({ name: plugin, marketplace }), '--scope', scope], cwd);
+        await this.rufen(ziel.ort, ['plugin', 'install', pluginSchluessel({ name: plugin, marketplace }), '--scope', scope], cwd);
     }
     async entfernen(plugin, marketplace, ziel) {
         const { scope, cwd } = this.scope(ziel);
-        await this.rufen(['plugin', 'uninstall', pluginSchluessel({ name: plugin, marketplace }), '--scope', scope], cwd);
+        await this.rufen(ziel.ort, ['plugin', 'uninstall', pluginSchluessel({ name: plugin, marketplace }), '--scope', scope], cwd);
     }
     /** Ohne Namen aktualisiert die CLI alle Marketplaces. Je Plugin verlangt sie einen Namen, das übernimmt hmgr nicht (E14). */
-    async aktualisieren() {
-        await this.rufen(['plugin', 'marketplace', 'update']);
+    async aktualisieren(ort) {
+        await this.rufen(ort, ['plugin', 'marketplace', 'update']);
+    }
+    async welten() {
+        return await this.harness.erreichbareWelten();
     }
     /**
      * Die Liste gilt nur für das cwd des Aufrufs und enthält dort alle Scopes. Zum Ort gehören im
      * Home die Plugins mit Scope `user`, im Arbeitsverzeichnis die mit `local` und `project`.
+     * E102: Die CLI listet die local-Einträge aller Projekte, je mit `projectPath`; am
+     * Arbeitsverzeichnis zählen nur die eigenen (ohne `projectPath` wie bisher). Verglichen wird mit
+     * dem CLI-Pfad (in WSL der Linux-Pfad) und lokal zusätzlich mit der aufgelösten Form, weil
+     * Claude Code den cwd auflöst.
      */
     async installierte(ziel) {
         const { cwd } = this.scope(ziel);
-        const { stdout, code } = await this.ausfuehrer(['plugin', 'list', '--json'], cwd);
+        const { stdout, code } = await (await this.cli(ziel.ort))(['plugin', 'list', '--json'], cwd);
         if (code !== 0)
             return [];
         const erlaubt = ziel.ort.art === 'home' ? ['user'] : ['local', 'project'];
+        const eigene = [];
+        if (ziel.ort.art === 'arbeitsverzeichnis') {
+            eigene.push(cwd ?? ziel.ort.pfad);
+            if (wslUncZerlegen(ziel.ort.pfad) === undefined)
+                eigene.push(aufgeloest(ziel.ort.pfad));
+        }
         return pluginListeLesen(stdout)
             .filter((eintrag) => erlaubt.includes(eintrag.scope))
+            .filter((eintrag) => ziel.ort.art !== 'arbeitsverzeichnis' ||
+            eintrag.projectPath === undefined ||
+            eigene.some((pfad) => pfadGleich(pfad, eintrag.projectPath)))
             .map((eintrag) => pluginSchluessel(eintrag));
     }
 }
@@ -222,8 +274,12 @@ function aufgeloest(pfad) {
  * Windows angelegte Datei leer.
  */
 async function projektMcpJsonLesen(verzeichnis) {
+    const text = await readFile(path.join(verzeichnis, '.mcp.json'), 'utf8').catch(() => undefined);
+    return text === undefined ? {} : mcpServersAusText(text);
+}
+/** `mcpServers` aus dem Text einer `.mcp.json`; kaputtes JSON heißt nichts, eine BOM stört nicht. */
+function mcpServersAusText(text) {
     try {
-        const text = await readFile(path.join(verzeichnis, '.mcp.json'), 'utf8');
         return mcpServersVon(JSON.parse(ohneBom(text)));
     }
     catch {
@@ -239,17 +295,43 @@ async function projektMcpJsonLesen(verzeichnis) {
  * geschrieben wird sie einzig von `geteiltenUebernehmen` auf ausdrücklichen Auftrag (E64). Format
  * und Verhalten der CLI stehen in HARNESS-FAKTEN.md, geprüft an Claude Code 2.1.261 gegen ein
  * eigenes CLAUDE_CONFIG_DIR, nie an einer echten Nutzerdatei.
+ *
+ * Welche CLI und welche Dateien, entscheidet der Ort (E100): ein WSL-Heim und ein Arbeitsverzeichnis
+ * unter `\\wsl$` gehen an die claude-CLI der Distro (cwd als Linux-Pfad), und gelesen werden
+ * `~/.claude.json` und `.mcp.json` der Distro über die Bridge — die Windows-Dateien wären die
+ * falschen. Vor jedem schreibenden Aufruf prüft die Fähigkeit, ob am Ort eine CLI antwortet;
+ * sonst hielte das idempotente Aushängen ein „nicht gefunden" der fehlenden CLI für Erfolg.
  */
 class ClaudeMcp {
     harness;
-    ausfuehrer;
     /** Das primäre Homedir, jedes Mal frisch: es lässt sich zur Laufzeit umstellen (E78, F89). */
     home;
-    constructor(harness, ausfuehrer, home) {
+    constructor(harness, home) {
         this.harness = harness;
-        this.ausfuehrer = ausfuehrer;
         this.home = home;
     }
+    /** Die claude-CLI des Orts, nachdem feststeht, dass sie antwortet (E100). */
+    async cli(ort) {
+        await this.harness.cliPruefen(ort);
+        return this.harness.ausfuehrerFuer(ort);
+    }
+    /** Der Pfad eines Arbeitsverzeichnisses in der Welt seiner CLI: in WSL der Linux-Pfad (E100). */
+    cliPfad(pfad) {
+        return cliPfad(pfad);
+    }
+    /** Wo die geteilte `.mcp.json` eines Arbeitsverzeichnisses liegt, in WSL als Linux-Pfad (E100). */
+    mcpJsonPfad(pfad) {
+        const wsl = wslUncZerlegen(pfad);
+        return wsl === undefined ? path.join(pfad, '.mcp.json') : path.posix.join(wsl.linuxPfad, '.mcp.json');
+    }
+    /** Die geteilte `.mcp.json` eines Arbeitsverzeichnisses, in WSL über die Bridge gelesen (E100). */
+    async projektMcpJson(pfad) {
+        const wsl = wslUncZerlegen(pfad);
+        if (wsl === undefined)
+            return await projektMcpJsonLesen(pfad);
+        const text = await this.harness.bruecke(wsl.distro).dateiLesen(this.mcpJsonPfad(pfad)).catch(() => undefined);
+        return text === undefined ? {} : mcpServersAusText(text);
+    }
     anGitWurzelGebunden = true;
     ebenen() {
         return ['home', 'arbeitsverzeichnis'];
@@ -257,12 +339,12 @@ class ClaudeMcp {
     hinweisNachAenderung() {
         return 'Claude Code übernimmt die Änderung mit der nächsten Sitzung.';
     }
+    /** Scope und cwd eines Ortes; das cwd steht in der Welt der zuständigen CLI (E100). */
     scope(ort) {
-        ohneCliZugriffPruefen(this.harness.name, ort, 'MCP-Server');
         if (ort.art === 'home')
             return { scope: 'user' };
         if (ort.art === 'arbeitsverzeichnis')
-            return { scope: 'local', cwd: ort.pfad };
+            return { scope: 'local', cwd: this.cliPfad(ort.pfad) };
         throw new OrtNichtUnterstuetzt(this.harness.name, ort.art);
     }
     /**
@@ -273,8 +355,9 @@ class ClaudeMcp {
      */
     async einhaengen(name, konfig, ort) {
         const { scope, cwd } = this.scope(ort);
+        const cli = await this.cli(ort);
         const json = claudeMcpJson(konfig);
-        const { stdout, code } = await this.ausfuehrer(['mcp', 'add-json', name, json, '--scope', scope], cwd);
+        const { stdout, code } = await cli(['mcp', 'add-json', name, json, '--scope', scope], cwd);
         if (code === 0)
             return;
         const bestehend = await this.eintrag(name, ort);
@@ -294,15 +377,16 @@ class ClaudeMcp {
      */
     async aushaengen(name, ort) {
         const { scope, cwd } = this.scope(ort);
-        const { stdout, code } = await this.ausfuehrer(['mcp', 'remove', name, '--scope', scope], cwd);
+        const cli = await this.cli(ort);
+        const { stdout, code } = await cli(['mcp', 'remove', name, '--scope', scope], cwd);
         if (code === 0)
             return;
         if ((await this.eintrag(name, ort)) !== undefined)
             throw new Error(`claude mcp remove ${name} scheiterte (Code ${code}): ${stdout.trim()}`);
         if (ort.art === 'arbeitsverzeichnis') {
-            const geteilt = await projektMcpJsonLesen(ort.pfad);
+            const geteilt = await this.projektMcpJson(ort.pfad);
             if (name in geteilt)
-                throw new McpNurGeteilterFundort({ harness: this.harness.name, ort }, name, path.join(ort.pfad, '.mcp.json'));
+                throw new McpNurGeteilterFundort({ harness: this.harness.name, ort }, name, this.mcpJsonPfad(ort.pfad));
         }
     }
     async eingehaengte(ort) {
@@ -310,16 +394,14 @@ class ClaudeMcp {
     }
     /**
      * Die geteilte `.mcp.json` eines Arbeitsverzeichnisses (E61-Nachtrag): im Alltag nur gelesen,
-     * weder beim Ein- noch beim Aushängen angefasst. Home kennt keine solche Datei.
+     * weder beim Ein- noch beim Aushängen angefasst. Home kennt keine solche Datei. In WSL liegt sie
+     * im Linux-Dateisystem und wird über die Bridge gelesen, der Pfad steht als Linux-Pfad da (E100).
      */
     async geteilteFundorte(ort) {
         if (ort.art !== 'arbeitsverzeichnis')
             return [];
-        // In WSL gibt es hier nichts zu übernehmen (E96): die MCP-Verwaltung ist dort gesperrt.
-        if (wslUncZerlegen(ort.pfad) !== undefined)
-            return [];
-        const datei = path.join(ort.pfad, '.mcp.json');
-        const server = await projektMcpJsonLesen(ort.pfad);
+        const datei = this.mcpJsonPfad(ort.pfad);
+        const server = await this.projektMcpJson(ort.pfad);
         return Object.keys(server).map((name) => ({ name, datei, scope: 'project' }));
     }
     /**
@@ -341,12 +423,13 @@ class ClaudeMcp {
         const ziel = { harness: this.harness.name, ort };
         if (ort.art !== 'arbeitsverzeichnis')
             throw new McpUebernahmeNichtMoeglich(ziel);
-        ohneCliZugriffPruefen(this.harness.name, ort, 'MCP-Server');
-        const datei = path.join(ort.pfad, '.mcp.json');
-        const block = (await projektMcpJsonLesen(ort.pfad))[name];
+        const datei = this.mcpJsonPfad(ort.pfad);
+        const block = (await this.projektMcpJson(ort.pfad))[name];
         if (block === undefined)
             throw new McpNichtInGeteilterDatei(ziel, name, datei);
-        const hin = await this.ausfuehrer(['mcp', 'add-json', name, JSON.stringify(block), '--scope', 'local'], ort.pfad);
+        const cli = await this.cli(ort);
+        const cwd = this.cliPfad(ort.pfad);
+        const hin = await cli(['mcp', 'add-json', name, JSON.stringify(block), '--scope', 'local'], cwd);
         if (hin.code !== 0) {
             // Der einzige harmlose Fehlschlag: derselbe Block liegt schon im privaten Scope, etwa weil ein
             // früherer Lauf zwischen den beiden Schritten abgebrochen ist. Ein abweichender Block wird
@@ -357,10 +440,10 @@ class ClaudeMcp {
             if (!tiefGleich(bestehend, block))
                 throw new McpAbweichenderEintrag(ziel, name);
         }
-        const weg = await this.ausfuehrer(['mcp', 'remove', name, '--scope', 'project'], ort.pfad);
+        const weg = await cli(['mcp', 'remove', name, '--scope', 'project'], cwd);
         // Nicht der Code entscheidet, sondern die Datei danach: steht der Name nicht mehr drin, ist die
         // Übernahme fertig, egal wie die CLI den Fall genannt hat.
-        if (weg.code !== 0 && name in (await projektMcpJsonLesen(ort.pfad)))
+        if (weg.code !== 0 && name in (await this.projektMcpJson(ort.pfad)))
             throw new McpUebernahmeUnvollstaendig(ziel, name, datei, weg.stdout.trim());
         return { datei };
     }
@@ -375,23 +458,35 @@ class ClaudeMcp {
      * Ordner in einem Git-Repo, ist der Schlüssel die Git-Wurzel, nicht der Ordner (E91, belegt an
      * 2.1.285): für einen Unterordner liest diese Methode deshalb nichts, und der Kern sperrt dort
      * die MCP-Operationen, bevor sie den Adapter erreichen.
+     *
+     * In WSL (E100) ist es die `~/.claude.json` der Distro, über die Bridge gelesen; der Schlüssel ist
+     * der Linux-Pfad, zusätzlich in der Distro aufgelöst (`realpath`).
      */
     async mcpServersAm(ort) {
-        ohneCliZugriffPruefen(this.harness.name, ort, 'MCP-Server');
-        const daten = await this.claudeJsonLesen();
+        const distro = wslDistroVonOrt(ort);
+        const daten = await this.claudeJsonLesen(distro);
         if (ort.art === 'home')
             return mcpServersVon(daten);
         if (ort.art === 'arbeitsverzeichnis') {
             const projects = objektFeld(daten, 'projects');
-            const projekt = objektFeld(projects, ort.pfad) ?? objektFeld(projects, aufgeloest(ort.pfad));
-            return mcpServersVon(projekt);
+            const pfad = this.cliPfad(ort.pfad);
+            const direkt = objektFeld(projects, pfad);
+            if (direkt !== undefined)
+                return mcpServersVon(direkt);
+            const echt = distro === undefined
+                ? aufgeloest(pfad)
+                : await this.harness.bruecke(distro).aufgeloest(pfad).catch(() => undefined);
+            return mcpServersVon(echt === undefined ? undefined : objektFeld(projects, echt));
         }
         throw new OrtNichtUnterstuetzt(this.harness.name, ort.art);
     }
-    async claudeJsonLesen() {
+    /** `~/.claude.json`: unter Windows die im primären Homedir, in WSL die der Distro (E100). */
+    async claudeJsonLesen(distro) {
         try {
-            const text = await readFile(path.join(this.home(), '.claude.json'), 'utf8');
-            return JSON.parse(ohneBom(text));
+            const text = distro === undefined
+                ? await readFile(path.join(this.home(), '.claude.json'), 'utf8')
+                : await this.harness.bruecke(distro).claudeJsonLesen();
+            return text === undefined ? undefined : JSON.parse(ohneBom(text));
         }
         catch {
             return undefined;
@@ -404,42 +499,123 @@ export class ClaudeCode {
     ausfuehrer;
     /** Zugriff je Ort (E78): lokal wie bisher, für ein WSL-Heim die Bridge. */
     zugriffFuer;
-    /** Wird von `vorhanden()` gesetzt, sobald die claude-CLI auf dem PATH liegt. */
+    /** Die WSL-Anbindung (E100): claude-CLI je Ort, Bridge je Distro, Distros der eingetragenen Orte. */
+    wsl;
+    /**
+     * Plugins (E16) und MCP-Server (E61) setzt `vorhanden()`, sobald irgendwo eine claude-CLI
+     * antwortet (E100, E101): unter Windows oder in der Distro eines eingetragenen WSL-Orts. Ob es an
+     * einem bestimmten Ort geht, entscheidet der Ort (`cliPruefen`).
+     */
     plugins;
-    /** Wird von `vorhanden()` gesetzt, sobald die claude-CLI auf dem PATH liegt (E61). */
     mcp;
-    geprueft = false;
+    /** Ob die claude-CLI antwortet, je Welt einmal je Lauf: Schlüssel '' für Windows, sonst die Distro. */
+    erreichbarkeit = new Map();
     /**
      * `heime` sagt, wo die Homedirs liegen (E78): das primäre und, seit F87, zusätzliche in einer
      * WSL-Distro. Ein blanker Pfad steht weiterhin für „nur dieses eine Home", damit Tests und
-     * Aufrufer ohne Zustand unverändert bleiben.
+     * Aufrufer ohne Zustand unverändert bleiben. `wsl` verdrahtet `bauen` (E100); ohne Angabe gehen
+     * die Aufrufe an das echte wsl.exe, und als WSL-Orte zählen nur die zusätzlichen Heime.
      */
-    constructor(heime, ausfuehrer = claudeAusfuehrer, zugriffFuer) {
+    constructor(heime, ausfuehrer = claudeAusfuehrer, zugriffFuer, wsl) {
         this.heime = typeof heime === 'string' ? nurHome(heime) : heime;
         this.ausfuehrer = ausfuehrer;
         const lokal = new LokalerZugriff();
         this.zugriffFuer = zugriffFuer ?? (() => lokal);
+        const bruecken = new Map();
+        const langeBridge = wslAusfuehrerMit(120_000);
+        this.wsl = {
+            ausfuehrerFuer: wsl?.ausfuehrerFuer ??
+                ((ort) => {
+                    const distro = wslDistroVonOrt(ort);
+                    return distro === undefined ? this.ausfuehrer : wslClaudeAusfuehrer(distro, langeBridge);
+                }),
+            bruecke: wsl?.bruecke ??
+                ((distro) => {
+                    let b = bruecken.get(distro);
+                    if (b === undefined)
+                        bruecken.set(distro, (b = new WslBruecke(distro)));
+                    return b;
+                }),
+            distros: wsl?.distros ??
+                (async () => this.heime
+                    .zusaetzliche(this.name)
+                    .map((heim) => wslDistroVonOrt({ art: 'home', heim: heim.adresse }))
+                    .filter((distro) => distro !== undefined)),
+        };
+    }
+    /** Die claude-CLI, die für diesen Ort zuständig ist (E100): die des Rechners oder die der Distro. */
+    ausfuehrerFuer(ort) {
+        return this.wsl.ausfuehrerFuer(ort);
+    }
+    /** Die Bridge in eine Distro, für das Lesen ihrer Dateien (E100). */
+    bruecke(distro) {
+        return this.wsl.bruecke(distro);
+    }
+    /** Ob an diesem Ort eine claude-CLI antwortet (`claude --version`), je Welt einmal je Lauf. */
+    async erreichbar(ort) {
+        const schluessel = wslDistroVonOrt(ort) ?? '';
+        let versprechen = this.erreichbarkeit.get(schluessel);
+        if (versprechen === undefined) {
+            const cli = schluessel === '' ? this.ausfuehrer : this.ausfuehrerFuer(ort);
+            versprechen = cli(['--version'])
+                .then(({ code }) => code === 0)
+                .catch(() => false);
+            this.erreichbarkeit.set(schluessel, versprechen);
+        }
+        return await versprechen;
+    }
+    /** Wirft `ClaudeCliNichtErreichbar`, wenn an diesem Ort keine claude-CLI antwortet (E100). */
+    async cliPruefen(ort) {
+        if (!(await this.erreichbar(ort)))
+            throw new ClaudeCliNichtErreichbar({ harness: this.name, ort }, wslDistroVonOrt(ort));
     }
     /**
      * Claude Code liegt auf dem Rechner, wenn es sein Home angelegt hat — oder wenn ein zusätzliches
      * Homedir eingetragen ist (E78): wer eines eingetragen hat, hat Claude Code dort laufen, und ein
-     * Windows-Home ohne `.claude` soll die WSL-Ziele nicht mit verschwinden lassen. Die Plugin- und
-     * MCP-Fähigkeit kommen dazu, sobald `claude --version` durchläuft: ohne CLI gibt es beides nicht.
+     * Windows-Home ohne `.claude` soll die WSL-Ziele nicht mit verschwinden lassen.
+     *
+     * Die Plugin- und die MCP-Fähigkeit (E100, E101) kommen dazu, sobald `claude --version` unter
+     * Windows durchläuft — oder, wenn dort keine CLI liegt, sobald sie in der Distro eines
+     * eingetragenen WSL-Orts antwortet. Die Distros werden erst dann befragt, nacheinander bis zur
+     * ersten Antwort, damit ein Rechner mit Windows-claude keinen wsl.exe-Start zahlt. Jede Welt wird
+     * einmal je Lauf geprüft; in der GUI kommt ein später eingetragener WSL-Ort beim nächsten Aufruf
+     * dazu, ohne die schon geprüften erneut zu fragen.
      */
     async vorhanden() {
         const primaer = this.heime.primaer(this.name);
         const da = (await stat(path.join(primaer, CLAUDE_VERZEICHNIS)).catch(() => undefined)) !== undefined ||
             this.heime.zusaetzliche(this.name).length > 0;
-        if (!this.geprueft) {
-            this.geprueft = true;
-            const { code } = await this.ausfuehrer(['--version']).catch(() => ({ code: 1 }));
-            if (code === 0) {
-                this.plugins = new ClaudePlugins(this, this.ausfuehrer);
-                this.mcp = new ClaudeMcp(this, this.ausfuehrer, () => this.heime.primaer(this.name));
-            }
+        if (this.mcp === undefined && (await this.irgendwoErreichbar())) {
+            this.plugins = new ClaudePlugins(this);
+            this.mcp = new ClaudeMcp(this, () => this.heime.primaer(this.name));
         }
         return da;
     }
+    /** Antwortet irgendwo eine claude-CLI: unter Windows oder in einer Distro der WSL-Orte (E100). */
+    async irgendwoErreichbar() {
+        if (await this.erreichbar({ art: 'home' }))
+            return true;
+        const distros = await this.wsl.distros().catch(() => []);
+        for (const distro of new Set(distros))
+            if (await this.erreichbar(distroOrt(distro)))
+                return true;
+        return false;
+    }
+    /**
+     * Je Welt mit antwortender claude-CLI ein Ort, der für sie steht (E101): das Windows-Home und je
+     * Distro der eingetragenen WSL-Orte ihr Heim. Anders als `irgendwoErreichbar` fragt es alle
+     * Distros, auch wenn Windows schon antwortet — jede Welt hat ihre eigenen Marketplaces.
+     */
+    async erreichbareWelten() {
+        const welten = [];
+        if (await this.erreichbar({ art: 'home' }))
+            welten.push({ art: 'home' });
+        const distros = await this.wsl.distros().catch(() => []);
+        for (const distro of new Set(distros))
+            if (await this.erreichbar(distroOrt(distro)))
+                welten.push(distroOrt(distro));
+        return welten;
+    }
     orte() {
         return ['home', 'arbeitsverzeichnis'];
     }

package/dist/adapter/git.js

@@ -121,10 +121,39 @@ async function dateienAufPlatte(wurzel, unter = '') {
     }
     return dateien;
 }
+/**
+ * Wartezeiten zwischen den Versuchen bei belegter git-Sperre (E99): 5 Versuche, zusammen rund 3 s.
+ * Tests übergeben kürzere über den Konstruktor.
+ */
+export const SPERRE_WARTEZEITEN_MS = [200, 400, 800, 1600];
+/** Meldung, mit der git eine belegte Sperrdatei anzeigt (E99). */
+const SPERRE_BELEGT = /Unable to create '[^']+\.lock': File exists/;
 export class GitQuellen {
     wurzel;
-    constructor(wurzel) {
+    sperreWartezeitenMs;
+    constructor(wurzel, optionen = {}) {
         this.wurzel = wurzel;
+        this.sperreWartezeitenMs = optionen.sperreWartezeitenMs ?? SPERRE_WARTEZEITEN_MS;
+    }
+    /**
+     * Wiederholt einen git-Aufruf, wenn eine fremde Sperre ihn blockiert (E99): GUI-Aktionen und der
+     * Start-Lauf rufen git parallel auf, und git bricht bei `….lock: File exists` sofort ab. Nur
+     * diese Meldung wird wiederholt, jeder andere Fehler gilt sofort. Nach dem letzten Versuch bleibt
+     * die bisherige Fehlermeldung. hmgr löscht fremde Sperren nie, auch keine verwaisten.
+     */
+    async mitSperrWiederholung(aufruf) {
+        for (let versuch = 0;; versuch++) {
+            try {
+                return await aufruf();
+            }
+            catch (fehler) {
+                const wartezeit = this.sperreWartezeitenMs[versuch];
+                const meldung = fehler instanceof Error ? fehler.message : String(fehler);
+                if (wartezeit === undefined || !SPERRE_BELEGT.test(meldung))
+                    throw fehler;
+                await new Promise((fertig) => setTimeout(fertig, wartezeit));
+            }
+        }
     }
     /**
      * stdin ist zu und git darf nicht nach Zugangsdaten fragen, sonst hängt ein wartender Aufruf
@@ -132,6 +161,9 @@ export class GitQuellen {
      * als dort, ein erster Clone über ein langsames Netz braucht Zeit.
      */
     async git(args, cwd) {
+        return await this.mitSperrWiederholung(() => this.gitEinmal(args, cwd));
+    }
+    async gitEinmal(args, cwd) {
         return await new Promise((erfuellen, ablehnen) => {
             const kind = spawn('git', args, {
                 cwd,
@@ -155,6 +187,9 @@ export class GitQuellen {
     }
     /** Wie `git`, aber mit Text auf stdin und Bytes als Ergebnis: `execFile` kennt keine Eingabe. */
     async gitMitEingabe(args, cwd, eingabe) {
+        return await this.mitSperrWiederholung(() => this.gitMitEingabeEinmal(args, cwd, eingabe));
+    }
+    async gitMitEingabeEinmal(args, cwd, eingabe) {
         return await new Promise((erfuellen, ablehnen) => {
             const kind = spawn('git', args, { cwd, timeout: 300_000, killSignal: 'SIGKILL' });
             const stuecke = [];

package/dist/adapter/wsl.js

@@ -6,20 +6,51 @@ import path from 'node:path';
 import { WslBrueckeFehlgeschlagen } from "../kern/modell.js";
 import { mitZeitlimit } from "./zeitlimit.js";
 /**
- * Standard-Ausführer: `wsl.exe` vom PATH, über cross-spawn wie die claude-CLI (E65/B7). stdin ist
- * zu, sonst hängt eine Distro, die auf Eingabe wartet; der Timeout (E98, `mitZeitlimit`) fängt alles Übrige. Ein
- * Fehlschlag wird zum Code, nicht zur Ausnahme.
+ * Ein Ausführer für `wsl.exe` vom PATH, über cross-spawn wie die claude-CLI (E65/B7). stdin ist zu,
+ * sonst hängt eine Distro, die auf Eingabe wartet; das Zeitlimit (E98, `mitZeitlimit`) fängt alles
+ * Übrige. Ein Fehlschlag wird zum Code, nicht zur Ausnahme.
  */
-export const wslAusfuehrer = (args) => new Promise((aufloesen) => {
-    const kind = spawn('wsl.exe', args, { stdio: ['ignore', 'pipe', 'pipe'] });
-    mitZeitlimit(kind, 60_000);
-    const teile = [];
-    const fehlerTeile = [];
-    kind.stdout.on('data', (d) => teile.push(d));
-    kind.stderr.on('data', (d) => fehlerTeile.push(d));
-    kind.on('error', (fehler) => aufloesen({ ausgabe: Buffer.from(fehler.message, 'utf8'), code: 1 }));
-    kind.on('close', (code) => aufloesen({ ausgabe: Buffer.concat(code === 0 ? teile : [...teile, ...fehlerTeile]), code: code ?? 1 }));
-});
+export function wslAusfuehrerMit(zeitlimitMs) {
+    return (args) => new Promise((aufloesen) => {
+        const kind = spawn('wsl.exe', args, { stdio: ['ignore', 'pipe', 'pipe'] });
+        mitZeitlimit(kind, zeitlimitMs);
+        const teile = [];
+        const fehlerTeile = [];
+        kind.stdout.on('data', (d) => teile.push(d));
+        kind.stderr.on('data', (d) => fehlerTeile.push(d));
+        kind.on('error', (fehler) => aufloesen({ ausgabe: Buffer.from(fehler.message, 'utf8'), code: 1 }));
+        kind.on('close', (code) => aufloesen({ ausgabe: Buffer.concat(code === 0 ? teile : [...teile, ...fehlerTeile]), code: code ?? 1 }));
+    });
+}
+/** Standard-Ausführer der Bridge: 60 s je Aufruf. */
+export const wslAusfuehrer = wslAusfuehrerMit(60_000);
+/**
+ * Sucht die claude-CLI in der Distro und ruft sie mit den übrigen Argumenten auf (E100). `sh -lc`
+ * liest das Login-Profil, damit `~/.local/bin` des Native-Installers im PATH steht; der Rückfall auf
+ * `$HOME/.local/bin/claude` greift, wenn das Profil ihn nicht einträgt. Gemessen in Ubuntu (dash) und
+ * Alpine (busybox), HARNESS-FAKTEN „claude-CLI in einer WSL-Distro aufrufen".
+ */
+export const CLAUDE_IN_WSL_SKRIPT = 'c=$(command -v claude || echo "$HOME/.local/bin/claude"); exec "$c" "$@"';
+/**
+ * Die Argumente an wsl.exe für ein Programm in der Distro (E100). Nur `--exec` reicht jedes Argument
+ * unverändert durch; ohne (und mit `--`) setzt wsl.exe die Zeile zusammen und lässt sie von der
+ * Distro-Shell neu zerlegen, Positionsargumente gingen verloren (gemessen).
+ */
+export function wslExecArgs(distro, programm, cwd) {
+    return ['-d', distro, ...(cwd === undefined ? [] : ['--cd', cwd]), '--exec', ...programm];
+}
+/**
+ * Die claude-CLI einer Distro als Ausführer (E100), in derselben Form wie der Windows-Ausführer:
+ * `cwd` ist hier ein Linux-Pfad der Distro und geht als `--cd` an wsl.exe. Ausgabe UTF-8 (Ausgabe
+ * eines Linux-Programms über die Bridge, gemessen). Liegt keine claude in der Distro, endet das
+ * Skript mit Code 127.
+ */
+export function wslClaudeAusfuehrer(distro, ausfuehren) {
+    return async (args, cwd) => {
+        const { ausgabe, code } = await ausfuehren(wslExecArgs(distro, ['sh', '-lc', CLAUDE_IN_WSL_SKRIPT, 'claude', ...args], cwd));
+        return { stdout: ausgabe.toString('utf8'), code };
+    };
+}
 /**
  * Eine wsl.exe-eigene Ausgabe als Text (E78, gemessen): UTF-16LE, mit BOM. Node kennt die Kodierung
  * als „utf16le"; die BOM bleibt beim Dekodieren als `\uFEFF` stehen und wird hier entfernt. Ein
@@ -96,6 +127,45 @@ export class WslBruecke {
             throw new WslBrueckeFehlgeschlagen(this.distro, text);
         return text;
     }
+    /**
+     * Ein Programm in der Distro über `--exec` (E100): Argumente kommen unverändert an, `cwd` ist ein
+     * Linux-Pfad. Ausgabe UTF-8; ein Fehlschlag ist kein Fehler, sondern ein Code.
+     */
+    async exec(programm, cwd) {
+        const { ausgabe, code } = await this.ausfuehren(wslExecArgs(this.distro, programm, cwd));
+        return { text: ausgabe.toString('utf8'), code };
+    }
+    /** Eine Datei der Distro als Text; `undefined`, wenn sie fehlt oder die Bridge schweigt. */
+    async dateiLesen(pfad) {
+        const { text, code } = await this.exec(['cat', pfad]);
+        return code === 0 ? text : undefined;
+    }
+    /** `~/.claude.json` des Standardbenutzers der Distro (E100); `undefined` ohne Datei. */
+    async claudeJsonLesen() {
+        const { text, code } = await this.exec(['sh', '-c', 'cat "$HOME/.claude.json"']);
+        return code === 0 ? text : undefined;
+    }
+    /** Der in der Distro aufgelöste Pfad (`realpath`); `undefined`, wenn es ihn nicht gibt. */
+    async aufgeloest(pfad) {
+        const { text, code } = await this.exec(['realpath', pfad]);
+        const echt = text.trim();
+        return code === 0 && echt.length > 0 ? echt : undefined;
+    }
+    /**
+     * Die Git-Wurzel, in der ein Linux-Pfad liegt, und der Pfad relativ dazu (E91, E100). Über die
+     * Bridge, weil git für Windows ein Repo unter `\\wsl$` als „dubious ownership" ablehnt (gemessen).
+     * `--show-prefix` ist an der Wurzel selbst leer; ein Vergleich der Pfade wäre an einem Symlink im
+     * Pfad falsch. Kein Repo, kein git in der Distro oder kein Ordner: `null`.
+     */
+    async gitWurzel(pfad) {
+        const { text, code } = await this.exec(['git', 'rev-parse', '--show-toplevel', '--show-prefix'], pfad);
+        if (code !== 0)
+            return null;
+        const [wurzel, prefix] = text.split('\n').map((zeile) => zeile.replace(/\r$/, '').trim());
+        if (wurzel === undefined || wurzel.length === 0)
+            return null;
+        return { wurzel, relativerPfad: (prefix ?? '').replace(/\/+$/, '') };
+    }
     /** Dasselbe, aber ein Fehlschlag ist kein Fehler: `undefined`. Für lesende Abfragen. */
     async shWeich(skript) {
         const { ausgabe, code } = await this.ausfuehren(['-d', this.distro, '/bin/sh', '-c', skript]);

package/dist/cli/hilfe.js

@@ -106,8 +106,9 @@ Harnesses, die hmgr verwaltet: standardmäßig nur claude-code (E38).
 
 Ein Arbeitsverzeichnis unter Windows, das in einer WSL-Distro liegt (\\\\wsl$\\<distro>\\… oder
 \\\\wsl.localhost\\<distro>\\…, E96), bedient hmgr über die Bridge dieser Distro, wie ein Homedir in
-WSL: der Link liegt im Linux-Dateisystem und zeigt auf den Windows-Checkout (/mnt/c). MCP-Server und
-Plugins gibt es dort nicht, die claude-CLI dieses Rechners schreibt nur in die Windows-Konfiguration.
+WSL: der Link liegt im Linux-Dateisystem und zeigt auf den Windows-Checkout (/mnt/c). MCP-Server
+hängt hmgr dort über die claude-CLI der Distro ein (hmgr help mcp, E100). Plugins gibt es dort noch
+nicht, die claude-CLI dieses Rechners schreibt sie nur in die Windows-Konfiguration.
 
 Schalter:
   --composer <pfad>   nur bei add: composer.json wählen, wenn unter dem Verzeichnis mehrere in
@@ -228,11 +229,21 @@ Das Schreiben in einen Zeiger ist gesperrt, bis das Composer-Thema entschieden i
 Arbeitsverzeichnis mit Zeiger brechen add und remove ohne --local ab, nichts wird installiert,
 verlinkt oder entfernt.
 
+Unter Windows gehen Plugins auch in WSL (E101): im Homedir einer Distro (--ort wsl:<distro>,
+eingetragen mit hmgr harness home claude-code add wsl:<distro>) und in einem Arbeitsverzeichnis
+unter \\\\wsl$\\<distro>\\… oder \\\\wsl.localhost\\<distro>\\…. hmgr ruft dann die claude-CLI der Distro
+über wsl.exe auf, wie bei MCP-Servern. Jede Claude-Installation führt ihre eigene Marketplace-Liste:
+hmgr trägt den Marketplace in der Distro ein, und hmgr update zieht die Marketplaces unter Windows
+und in jeder Distro der eingetragenen WSL-Orte nach, sofern dort eine claude antwortet. Der
+Marketplace wird in der Distro geklont: eine SSH-URL oder ein privates HTTPS-Repo braucht dort
+eigene Schlüssel bzw. Zugangsdaten, die von Windows gelten nicht. Welche claude zuständig ist,
+entscheidet der Ort: liegt sie nur in WSL, gehen das Windows-Home und Windows-Arbeitsverzeichnisse
+nicht, und umgekehrt.
+
 Schalter (add und remove):
   --harness <name>    claude-code, hermes oder agents, Standard claude-code
-  --ort <ort>         home, dir:<pfad> oder profil:<name>, Standard home. profil kennt nur hermes.
-                      Ein zusätzliches Homedir (wsl:<distro>) kennt die claude-CLI nicht, dort
-                      gibt es keine Plugins (E78)
+  --ort <ort>         home, wsl:<distro>, dir:<pfad> oder profil:<name>, Standard home. profil
+                      kennt nur hermes
   --composer <pfad>   composer.json des Arbeitsverzeichnisses, wenn mehrere in Frage kommen
   --local             Plugin nicht in den Zeiger schreiben
   --quelle <teil>     nur bei add: Quelle eingrenzen, wenn der Name in mehreren Marketplaces steht
@@ -240,6 +251,7 @@ Schalter (add und remove):
 Beispiele:
   hmgr plugin list
   hmgr plugin add superpowers --ort dir:.
+  hmgr plugin add superpowers --ort wsl:Ubuntu
   hmgr plugin remove superpowers
 
 Häufige Fälle:
@@ -394,6 +406,17 @@ mcp remove und mcp migrate: die Meldung nennt den Wurzelordner, dort gehören di
 noch kein Arbeitsverzeichnis: hmgr dir add <wurzel>). Die Wurzel selbst und Ordner ohne Repo gehen
 wie gewohnt.
 
+Unter Windows geht MCP auch in WSL (E100): im Homedir einer Distro (--ort wsl:<distro>, eingetragen
+mit hmgr harness home claude-code add wsl:<distro>) und in einem Arbeitsverzeichnis unter
+\\\\wsl$\\<distro>\\… oder \\\\wsl.localhost\\<distro>\\…. hmgr ruft dann die claude-CLI der Distro über
+wsl.exe auf und liest deren ~/.claude.json, nicht die von Windows; gesucht wird claude in einer
+Login-Shell der Distro (command -v claude), sonst unter ~/.local/bin/claude. Die .mcp.json eines
+solchen Projekts nennt hmgr mit ihrem Linux-Pfad. Die Git-Wurzel (siehe oben) ermittelt git in der
+Distro, die Meldung nennt sie als \\\\wsl$-Pfad. Welche claude
+zuständig ist, entscheidet der Ort: liegt sie nur in WSL, gehen das Windows-Home und
+Windows-Arbeitsverzeichnisse nicht, und umgekehrt. Plugins gehen in WSL auf demselben Weg (E101,
+hmgr help plugin).
+
 mcp migrate ist der einzige Weg, auf dem hmgr die geteilte .mcp.json anfasst (E64): der Eintrag
 wandert 1:1 aus der Datei in deinen privaten Scope am selben Ort und wird dort gelöscht. Auch ein
 Eintrag, der nicht im Katalog steht, lässt sich so übernehmen — der Konfigblock kommt aus der Datei,
@@ -411,11 +434,13 @@ und, bei einem Hermes-Ziel, zusätzlich gegen <hermes-home>/.env.
 
 Schalter (add, remove und migrate):
   --harness <name>    claude-code oder hermes, Standard claude-code
-  --ort <ort>         home, dir:<pfad> oder profil:<name>, Standard home
+  --ort <ort>         home, wsl:<distro>, dir:<pfad> oder profil:<name>, Standard home
 
 Beispiele:
   hmgr mcp list
   hmgr mcp add teamwork --ort dir:.
+  hmgr mcp add teamwork --ort wsl:Ubuntu
+  hmgr mcp add teamwork --ort dir:\\\\wsl$\\Ubuntu\\home\\kollege\\proj
   hmgr mcp add context7 --harness hermes --ort profil:researcher
   hmgr mcp remove teamwork --ort dir:.
   hmgr mcp migrate kollegen-tool --ort dir:.
@@ -431,6 +456,9 @@ Häufige Fälle:
   den Eintrag in den privaten Scope und löscht ihn aus der Datei.
   „gibt es keine geteilte Konfigurationsdatei": mcp migrate geht nur mit --harness claude-code und
   --ort dir:<pfad>.
+  „ist keine claude-CLI erreichbar": an diesem Ort antwortet keine claude. In WSL Claude Code in der
+  Distro installieren und mit wsl -d <distro> --exec sh -lc "command -v claude" prüfen; unter
+  Windows muss claude im PATH liegen.
 
 Siehe auch: hmgr help harness, hmgr help status`;
 const SYNC = `hmgr sync [pfad]
@@ -625,8 +653,9 @@ dort nutzt. Das Home wird einmal ermittelt (wsl -d <distro> /bin/sh -c 'echo $HO
 gespeichert. Jedes Homedir ist danach ein eigenständiges Ziel: es steht als eigene Zeile im status und
 wird mit --ort wsl:<distro> angesprochen. Gespiegelt wird nichts, jedes Ziel wird einzeln verlinkt.
 Links dort legt hmgr über wsl.exe an; das Linkziel bleibt der vorhandene Windows-Checkout, übersetzt
-nach /mnt/c. MCP-Server und Plugins gibt es dort nicht: die claude-CLI dieses Rechners bedient nur das
-primäre Homedir. remove lässt hmgr das Homedir vergessen, die Links dort bleiben liegen.
+nach /mnt/c. MCP-Server hängt hmgr dort über die claude-CLI der Distro ein (hmgr help mcp, E100).
+Plugins gibt es dort noch nicht: die claude-CLI dieses Rechners bedient sie nur im primären Homedir.
+remove lässt hmgr das Homedir vergessen, die Links dort bleiben liegen.
 
 Ein Arbeitsverzeichnis unter \\\\wsl$\\<distro>\\… bedient hmgr ebenso über die Distro (hmgr help dir, E96).
 

package/dist/cli/main.js

@@ -4,15 +4,15 @@ 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, BundleDateiFehler, BundleMehrdeutig, BundleMitgliederFehlen, BundleNamenskonflikte, BundleNichtInstalliert, BundleUnbekannt, EinschraenkungOhneZeiger, HarnessInaktiv, HarnessNichtVorhanden, HarnessTypUnbekannt, HeimAdresseUngueltig, HeimBereitsVorhanden, HeimFaehigkeitFehlt, HeimNurUnterWindows, ArbeitsverzeichnisOhneCliZugriff, HeimOhneCliZugriff, HeimUnbekannt, KeinPassenderRef, LinkAnlegenFehlgeschlagen, McpAbweichenderEintrag, McpEbeneNichtUnterstuetzt, McpFaehigkeitFehlt, McpKatalogFehler, McpNichtInGeteilterDatei, McpNurGeteilterFundort, McpOrtUnterGitWurzel, McpUebernahmeNichtMoeglich, McpUebernahmeUnvollstaendig, McpUnbekannt, NameBelegt, OrtNichtUnterstuetzt, PluginMehrdeutig, PluginUnbekannt, QuelleAufraeumenLokaleAenderungen, QuelleNameBelegt, QuelleUnbekannt, SkillMehrdeutig, SkillOrdnerBereitsVerwaltet, SkillOrdnerFaehigkeitFehlt, SkillOrdnerNichtVerwaltet, SkillOrdnerUngueltig, SkillUnbekannt, ZeigerMehrdeutig, WslBrueckeFehlgeschlagen, ZeigerSchreibenGesperrt, heimAdresseAlsText, heimAdresseZerlegen, wslDistroVonOrt, pluginSchluessel, quelleName, quelleSchluessel, } from "../kern/modell.js";
+import { Anwendungsfaelle, pluginWeltText, } from "../kern/anwendungsfaelle.js";
+import { AbhaengigkeitFehlt, BundleDateiFehler, BundleMehrdeutig, BundleMitgliederFehlen, BundleNamenskonflikte, BundleNichtInstalliert, BundleUnbekannt, EinschraenkungOhneZeiger, HarnessInaktiv, HarnessNichtVorhanden, HarnessTypUnbekannt, HeimAdresseUngueltig, HeimBereitsVorhanden, HeimFaehigkeitFehlt, HeimNurUnterWindows, ClaudeCliNichtErreichbar, HeimUnbekannt, KeinPassenderRef, LinkAnlegenFehlgeschlagen, McpAbweichenderEintrag, McpEbeneNichtUnterstuetzt, McpFaehigkeitFehlt, McpKatalogFehler, McpNichtInGeteilterDatei, McpNurGeteilterFundort, McpOrtUnterGitWurzel, McpUebernahmeNichtMoeglich, McpUebernahmeUnvollstaendig, McpUnbekannt, NameBelegt, OrtNichtUnterstuetzt, PluginMehrdeutig, PluginUnbekannt, QuelleAufraeumenLokaleAenderungen, QuelleNameBelegt, QuelleUnbekannt, SkillMehrdeutig, SkillOrdnerBereitsVerwaltet, SkillOrdnerFaehigkeitFehlt, SkillOrdnerNichtVerwaltet, SkillOrdnerUngueltig, SkillUnbekannt, ZeigerMehrdeutig, WslBrueckeFehlgeschlagen, ZeigerSchreibenGesperrt, heimAdresseAlsText, heimAdresseZerlegen, wslDistroVonOrt, wslUncZerlegen, pluginSchluessel, quelleName, quelleSchluessel, } from "../kern/modell.js";
 import { Agents } from "../adapter/agents.js";
 import { ClaudeCode, claudeAusfuehrer } from "../adapter/claude-code.js";
 import { Hermes } from "../adapter/hermes.js";
 import { ComposerZeiger } from "../adapter/composer.js";
 import { DateisystemZiele, LokalerZugriff } from "../adapter/dateisystem.js";
 import { ZustandHeime } from "../adapter/heime.js";
-import { WslBruecke, WslZugriff, wslAusfuehrer, wslDistros } from "../adapter/wsl.js";
+import { WslBruecke, WslZugriff, wslAusfuehrer, wslAusfuehrerMit, wslClaudeAusfuehrer, 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";
@@ -58,7 +58,33 @@ export function bauen(umgebung, optionen = {}) {
         const distro = wslDistroVonOrt(ort);
         return distro === undefined ? lokal : new WslZugriff(bruecke(distro));
     };
-    const claude = new ClaudeCode(heime, optionen.claudeAusfuehrer ?? claudeAusfuehrer, zugriffFuerOrt);
+    // Die claude-CLI je Ort (E100): für ein WSL-Heim und ein Arbeitsverzeichnis unter \\wsl$ die der
+    // Distro, über `wsl.exe --exec` mit eigenem Zeitlimit von 120 s wie unter Windows — nicht die 60 s
+    // der Bridge, `mcp add-json` startet in der Distro eine ganze Node-Laufzeit.
+    const windowsClaude = optionen.claudeAusfuehrer ?? claudeAusfuehrer;
+    const wslClaudeAusfuehren = optionen.wslAusfuehrer ?? wslAusfuehrerMit(120_000);
+    const claudeFuerOrt = (ort) => {
+        const distro = wslDistroVonOrt(ort);
+        return distro === undefined ? windowsClaude : wslClaudeAusfuehrer(distro, wslClaudeAusfuehren);
+    };
+    // Die Distros der eingetragenen WSL-Orte (E100): zusätzliche Heime und Arbeitsverzeichnisse unter
+    // \\wsl$. Hier statt im Adapter, weil nur der Zustand die Arbeitsverzeichnisse kennt. Außerhalb von
+    // Windows keine: ein von dort übernommener Zustand soll hier kein wsl.exe starten.
+    const wslDistrosDerOrte = async () => {
+        if (umgebungPort.plattform() !== 'win32')
+            return [];
+        const distros = heime
+            .zusaetzliche('claude-code')
+            .map((heim) => wslDistroVonOrt({ art: 'home', heim: heim.adresse }));
+        for (const pfad of (await zustand.lesen()).arbeitsverzeichnisse)
+            distros.push(wslUncZerlegen(pfad)?.distro);
+        return [...new Set(distros.filter((distro) => distro !== undefined))];
+    };
+    const claude = new ClaudeCode(heime, windowsClaude, zugriffFuerOrt, {
+        ausfuehrerFuer: claudeFuerOrt,
+        bruecke,
+        distros: wslDistrosDerOrte,
+    });
     const ports = {
         harnesses: [claude, new Hermes(heime, zugriffFuerOrt), new Agents(heime, zugriffFuerOrt)],
         quellen: new GitQuellen(wurzel),
@@ -72,6 +98,7 @@ export function bauen(umgebung, optionen = {}) {
         wsl: {
             distros: async () => await wslDistros(wslAusfuehren),
             home: async (distro) => await bruecke(distro).home(),
+            gitWurzel: async (distro, linuxPfad) => await bruecke(distro).gitWurzel(linuxPfad),
         },
         verlauf,
     };
@@ -729,7 +756,7 @@ export async function ausfuehren(argv, umgebung, optionen = {}) {
             : updateHinweis !== undefined
                 ? await anwendungsfaelle.quelleZuHinweis(updateHinweis)
                 : undefined;
-        const { checkouts: liste, bundles, aufraeumen, doctor, } = await anwendungsfaelle.aktualisieren({ ausloeser: 'cli', ...(nurQuelle === undefined ? {} : { quelle: nurQuelle }) });
+        const { checkouts: liste, pluginFehler, bundles, aufraeumen, doctor, } = await anwendungsfaelle.aktualisieren({ ausloeser: 'cli', ...(nurQuelle === undefined ? {} : { quelle: nurQuelle }) });
         if (liste.length === 0)
             console.log('Keine Checkouts.');
         for (const { checkout, aktualisierung, geaenderteSkills } of liste) {
@@ -748,6 +775,9 @@ export async function ausfuehren(argv, umgebung, optionen = {}) {
             else
                 console.log(`  fehlgeschlagen  ${kopf}  ${aktualisierung.fehler}`);
         }
+        // Plugins je Welt (E101): genannt wird nur ein Fehlschlag, eine Änderung lässt sich nicht messen (E80).
+        for (const { ziel, fehler } of pluginFehler)
+            console.log(`  fehlgeschlagen  Plugins ${ziel.harness} ${pluginWeltText(ziel.ort)}  ${fehler}`);
         // Bundles im selben Lauf (E69, F64=O1): eine geänderte Definition wird hier nachgezogen.
         for (const zeile of bundleBericht(bundles))
             console.log(zeile);
@@ -1152,8 +1182,7 @@ function istModellFehler(fehler) {
         fehler instanceof HeimBereitsVorhanden ||
         fehler instanceof HeimFaehigkeitFehlt ||
         fehler instanceof HeimNurUnterWindows ||
-        fehler instanceof HeimOhneCliZugriff ||
-        fehler instanceof ArbeitsverzeichnisOhneCliZugriff ||
+        fehler instanceof ClaudeCliNichtErreichbar ||
         fehler instanceof HeimUnbekannt ||
         fehler instanceof WslBrueckeFehlgeschlagen);
 }
@@ -1206,10 +1235,10 @@ function naechsterSchritt(fehler) {
         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 ArbeitsverzeichnisOhneCliZugriff)
-        return 'Skill-Links dort legt hmgr selbst: hmgr link <skill> --ort dir:<pfad>.';
-    if (fehler instanceof HeimOhneCliZugriff)
-        return 'Skill-Links dort legt hmgr selbst: hmgr link <skill> --harness claude-code --ort <adresse>.';
+    if (fehler instanceof ClaudeCliNichtErreichbar)
+        return fehler.distro === undefined
+            ? 'Claude Code hier installieren, oder an einem Ort arbeiten, an dem claude läuft, etwa --ort wsl:<distro>.'
+            : `Claude Code in der Distro installieren, dann prüfen: wsl -d ${fehler.distro} --exec sh -lc "command -v claude"`;
     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)

package/dist/gui/renderer/index.html

@@ -142,7 +142,7 @@
           <h1>MCP-Server</h1>
           <!-- Der Pfad steht hier in POSIX-Schreibweise und wird beim Start in die Schreibweise
                der Plattform gesetzt (E68, ladeUmgebung im Renderer). -->
-          <p>Dein Katalog aus <span class="mono" id="mcpkatalogpfad">~/.hmgr/mcp.yaml</span>. Häng einen Server dorthin ein, wo du ihn brauchst: in ein Arbeitsverzeichnis, damit er nur dort Kontext kostet, oder global. Den Katalog selbst pflegst du in der Datei, hmgr liest sie nur. Arbeitsverzeichnisse in WSL (\\wsl$\…) gehen dort nicht: die claude-CLI dieses Rechners kennt ihre Konfiguration nicht.</p>
+          <p>Dein Katalog aus <span class="mono" id="mcpkatalogpfad">~/.hmgr/mcp.yaml</span>. Häng einen Server dorthin ein, wo du ihn brauchst: in ein Arbeitsverzeichnis, damit er nur dort Kontext kostet, oder global. Den Katalog selbst pflegst du in der Datei, hmgr liest sie nur. In WSL – im Homedir einer Distro und in Arbeitsverzeichnissen unter \\wsl$\… – hängt hmgr den Server über die claude-CLI der Distro ein. Plugins gehen dort auf demselben Weg.</p>
         </div>
 
         <div class="mcpliste" id="mcpliste"></div>
@@ -167,7 +167,7 @@
       <section id="ansicht-plugins" hidden>
         <div class="ansichtskopf">
           <h1>Plugins</h1>
-          <p>Ein Marketplace ist eine Quelle mit einer <span class="mono">marketplace.json</span>. Die Plugins darin bündeln Skills und können voneinander abhängen. Harnesses ohne Plugin-Konzept bekommen von hmgr stattdessen die flache Skill-Liste verlinkt.</p>
+          <p>Ein Marketplace ist eine Quelle mit einer <span class="mono">marketplace.json</span>. Die Plugins darin bündeln Skills und können voneinander abhängen. Harnesses ohne Plugin-Konzept bekommen von hmgr stattdessen die flache Skill-Liste verlinkt. In WSL installiert hmgr Plugins über die claude-CLI der Distro; jede Claude-Installation führt ihre eigene Marketplace-Liste, hmgr trägt den Marketplace dort ein und zieht ihn beim Aktualisieren nach.</p>
         </div>
         <div id="pluginliste"></div>
       </section>

package/dist/kern/anwendungsfaelle.js

@@ -1,11 +1,19 @@
 // Anwendungsfälle. Pfade werden hier nur als Zeichenketten normalisiert, gelesen wird über die Ports.
 import path from 'node:path';
-import { AbhaengigkeitFehlt, BundleMehrdeutig, BundleMitgliederFehlen, BundleNamenskonflikte, BundleNichtInstalliert, BundleUnbekannt, EinschraenkungOhneZeiger, FremderEintragUnbekannt, HarnessInaktiv, HarnessNichtVorhanden, HarnessTypUnbekannt, HeimAdresseUngueltig, HeimBereitsVorhanden, HeimFaehigkeitFehlt, HeimNurUnterWindows, HeimUnbekannt, KeinPassenderRef, McpEbeneNichtUnterstuetzt, McpFaehigkeitFehlt, McpOrtUnterGitWurzel, McpUebernahmeNichtMoeglich, McpUnbekannt, OrtNichtUnterstuetzt, PluginMehrdeutig, PluginUnbekannt, QuelleAufraeumenLokaleAenderungen, QuelleNameBelegt, QuelleUnbekannt, SkillMehrdeutig, SkillOrdnerBereitsVerwaltet, SkillOrdnerFaehigkeitFehlt, SkillOrdnerNichtVerwaltet, SkillUnbekannt, ZeigerMehrdeutig, ZeigerSchreibenGesperrt, bundleSchluessel, heimAdresseAlsText, heimAdresseZerlegen, wslDistroVonOrt, wslUncZerlegen, marketplaceUrl, pluginSchluessel, pluginSchluesselZerlegen, quelleAlsText, quelleMitNamen, quelleName, quelleNameAbleiten, quelleNameFrei, quelleSchluessel, zielSchluessel, } from "./modell.js";
+import { AbhaengigkeitFehlt, BundleMehrdeutig, BundleMitgliederFehlen, BundleNamenskonflikte, BundleNichtInstalliert, BundleUnbekannt, EinschraenkungOhneZeiger, FremderEintragUnbekannt, HarnessInaktiv, HarnessNichtVorhanden, HarnessTypUnbekannt, HeimAdresseUngueltig, HeimBereitsVorhanden, HeimFaehigkeitFehlt, HeimNurUnterWindows, HeimUnbekannt, KeinPassenderRef, McpEbeneNichtUnterstuetzt, McpFaehigkeitFehlt, McpOrtUnterGitWurzel, McpUebernahmeNichtMoeglich, McpUnbekannt, OrtNichtUnterstuetzt, PluginMehrdeutig, PluginUnbekannt, QuelleAufraeumenLokaleAenderungen, QuelleNameBelegt, QuelleUnbekannt, SkillMehrdeutig, SkillOrdnerBereitsVerwaltet, SkillOrdnerFaehigkeitFehlt, SkillOrdnerNichtVerwaltet, SkillUnbekannt, ZeigerMehrdeutig, ZeigerSchreibenGesperrt, bundleSchluessel, heimAdresseAlsText, heimAdresseZerlegen, wslDistroVonOrt, wslUncBilden, wslUncZerlegen, marketplaceUrl, pluginSchluessel, pluginSchluesselZerlegen, quelleAlsText, quelleMitNamen, quelleName, quelleNameAbleiten, quelleNameFrei, quelleSchluessel, zielSchluessel, } from "./modell.js";
 import { mitBegrenzung } from "./begrenzung.js";
 import { passenderRef } from "./version.js";
 import { kannIstRegistriert, kannMcp, kannPlugins, kannProfile, kannSkillOrdner, kannZurueckbauen, kannZusaetzlicheHeime, } from "../ports/harness.js";
 /** So viele `plugin list`-Prozesse laufen im Ist-Zustand höchstens gleichzeitig (E93). */
 const PLUGIN_ABFRAGEN_GLEICHZEITIG = 6;
+/**
+ * Die Welt eines Orts als Text für Bericht und Verlauf (E101), in der Schreibweise von `--ort`:
+ * „home" für die Installation dieses Rechners, „wsl:<distro>" für die einer Distro.
+ */
+export function pluginWeltText(ort) {
+    const distro = wslDistroVonOrt(ort);
+    return distro === undefined ? 'home' : `wsl:${distro}`;
+}
 /**
  * Frage vor dem Löschen, eine für alle Kandidaten (E28). Der Kern formuliert sie fertig, der
  * Adapter stellt sie: Anzahl und Pfade, damit der Nutzer sieht, worüber er entscheidet.
@@ -357,6 +365,15 @@ export class Anwendungsfaelle {
     async mcpGitWurzelFuer(faehig, ziel) {
         if (faehig.anGitWurzelGebunden !== true || ziel.ort.art !== 'arbeitsverzeichnis')
             return null;
+        // In WSL fragt hmgr git in der Distro (E100); die Wurzel kommt in der Schreibweise des
+        // gespeicherten Pfads zurück, damit die Meldung einen Pfad nennt, den `hmgr dir add` nimmt.
+        const wsl = wslUncZerlegen(ziel.ort.pfad);
+        if (wsl !== undefined) {
+            const funde = await this.p.wsl.gitWurzel(wsl.distro, wsl.linuxPfad).catch(() => null);
+            if (funde === null || funde.relativerPfad === '')
+                return null;
+            return wslUncBilden(ziel.ort.pfad, funde.wurzel) ?? funde.wurzel;
+        }
         const kopie = await this.p.quellen.arbeitskopie(ziel.ort.pfad).catch(() => null);
         if (kopie === null || kopie.relativerPfad === '')
             return null;
@@ -464,18 +481,17 @@ export class Anwendungsfaelle {
             if (!kannMcp(harness))
                 continue;
             const ebenen = harness.mcp.ebenen();
-            // Nur das primäre Homedir (E78): die claude-CLI dieses Rechners bedient die Konfiguration
-            // einer WSL-Distro nicht, dort gibt es keine MCP-Server zu verwalten.
+            // Alle Homedirs samt WSL-Heimen und alle Arbeitsverzeichnisse samt denen unter \\wsl$ (E100):
+            // der Adapter spricht dort die claude-CLI der Distro an. Ob an einem Ort eine CLI antwortet,
+            // entscheidet er beim Schreiben; die Übersicht liest ohnehin nur.
             if (ebenen.includes('home'))
-                ziele.push({ harness: harness.name, ort: { art: 'home' } });
+                ziele.push(...this.homeZiele(harness));
             if (ebenen.includes('profil') && kannProfile(harness))
                 for (const name of await harness.profile())
                     ziele.push({ harness: harness.name, ort: { art: 'profil', name } });
-            // Arbeitsverzeichnisse in WSL (E96) ebenso nicht: ihre Konfiguration liegt in der Distro.
             if (ebenen.includes('arbeitsverzeichnis'))
                 for (const pfad of zustand.arbeitsverzeichnisse)
-                    if (wslUncZerlegen(pfad) === undefined)
-                        ziele.push(arbeitsverzeichnisZiel(harness.name, pfad));
+                    ziele.push(arbeitsverzeichnisZiel(harness.name, pfad));
         }
         return ziele;
     }
@@ -1526,8 +1542,9 @@ export class Anwendungsfaelle {
         if (!harness.orte().includes(ziel.ort.art))
             throw new OrtNichtUnterstuetzt(harness.name, ziel.ort.art);
         if (kannPlugins(harness)) {
-            if (!(await harness.plugins.marketplaceBekannt(fund.plugin.marketplace)))
-                await harness.plugins.marketplaceHinzufuegen(fund.plugin.marketplace, marketplaceUrl(fund.quelle));
+            // Die Marketplace-Liste gehört zur Welt des Ziels (E101): ein WSL-Ziel trägt ihn in der Distro ein.
+            if (!(await harness.plugins.marketplaceBekannt(fund.plugin.marketplace, ziel.ort)))
+                await harness.plugins.marketplaceHinzufuegen(fund.plugin.marketplace, marketplaceUrl(fund.quelle), ziel.ort);
             await harness.vorbereiten(ziel.ort);
             await harness.plugins.installieren(fund.plugin.name, fund.plugin.marketplace, ziel);
             return { plugin: fund.plugin, art: 'installiert', skills: [], imZeiger: false };
@@ -1860,13 +1877,26 @@ export class Anwendungsfaelle {
             }
             this.nachgezogen.add(quelleSchluessel(quelle));
         }
-        // Nach den Checkouts die Plugins nachziehen (E14).
+        // Nach den Checkouts die Plugins nachziehen (E14), je Welt mit erreichbarer Installation
+        // (E101): Windows und jede Distro der eingetragenen WSL-Orte haben ihre eigenen Marketplaces.
+        // Ein Fehlschlag in einer Welt steht im Ergebnis und bricht den Lauf nicht ab.
         const pluginHarnesses = [];
+        const pluginFehler = [];
         for (const harness of nurSchluessel !== undefined ? [] : await this.vorhandeneHarnesses()) {
             if (!kannPlugins(harness))
                 continue;
-            await harness.plugins.aktualisieren();
-            pluginHarnesses.push(harness.name);
+            let erfolgreich = false;
+            for (const ort of await harness.plugins.welten()) {
+                try {
+                    await harness.plugins.aktualisieren(ort);
+                    erfolgreich = true;
+                }
+                catch (fehler) {
+                    pluginFehler.push({ ziel: { harness: harness.name, ort }, fehler: fehlertext(fehler) });
+                }
+            }
+            if (erfolgreich)
+                pluginHarnesses.push(harness.name);
         }
         // Bundles vor dem Aufräumen (E69, F64=O1): der Abgleich legt und entfernt Links, und erst
         // danach steht fest, in welchen Checkout noch ein Link zeigt. Ein Fehlschlag je Bundle steckt
@@ -1878,15 +1908,16 @@ export class Anwendungsfaelle {
         const doctorErgebnis = nurSchluessel !== undefined
             ? { fehlendeArbeitsverzeichnisse: [], vergessen: [] }
             : await this.doctor({ rueckfragen });
-        await this.verlaufVermerken(ausloeser, this.aktualisierungsEreignisse(checkouts, bundles, aufraeumen, doctorErgebnis));
-        return { checkouts, pluginHarnesses, bundles, aufraeumen, doctor: doctorErgebnis };
+        await this.verlaufVermerken(ausloeser, this.aktualisierungsEreignisse(checkouts, pluginFehler, bundles, aufraeumen, doctorErgebnis));
+        return { checkouts, pluginHarnesses, pluginFehler, bundles, aufraeumen, doctor: doctorErgebnis };
     }
     /**
-     * Ereignisse eines Aktualisieren-Laufs für den Verlauf (E80): Plugins bleiben draußen, weil sich
-     * eine Änderung dort nicht messen lässt (`claude plugin marketplace update` liefert keine
-     * Auskunft) — die bisherige Zeile „Plugins aktualisiert" war deshalb geschönt.
+     * Ereignisse eines Aktualisieren-Laufs für den Verlauf (E80): eine Plugin-Änderung bleibt
+     * draußen, weil sie sich nicht messen lässt (`claude plugin marketplace update` liefert keine
+     * Auskunft) — die bisherige Zeile „Plugins aktualisiert" war deshalb geschönt. Ein Fehlschlag
+     * je Welt (E101) steht dagegen drin.
      */
-    aktualisierungsEreignisse(checkouts, bundles, aufraeumen, doctorErgebnis) {
+    aktualisierungsEreignisse(checkouts, pluginFehler, bundles, aufraeumen, doctorErgebnis) {
         const ereignisse = [];
         for (const { checkout, aktualisierung, geaenderteSkills } of checkouts) {
             if (aktualisierung.ergebnis === 'aktualisiert')
@@ -1905,6 +1936,8 @@ export class Anwendungsfaelle {
                     fehler: aktualisierung.fehler,
                 });
         }
+        for (const { ziel, fehler } of pluginFehler)
+            ereignisse.push({ art: 'fehler', betrifft: `Plugins ${ziel.harness} ${pluginWeltText(ziel.ort)}`, fehler });
         for (const eintrag of bundles) {
             if (eintrag.ergebnis === 'fehlgeschlagen')
                 ereignisse.push({ art: 'fehler', betrifft: eintrag.bundle, fehler: eintrag.fehler ?? '' });
@@ -2365,20 +2398,18 @@ export class Anwendungsfaelle {
         }
         // Installierte Plugins je Ziel vorab, mit begrenzter Parallelität (E93): `claude plugin list`
         // ist ein Prozess je Ziel (cwd-gebunden, kein Sammelaufruf), nacheinander dauert das bei vielen
-        // Arbeitsverzeichnissen Sekunden. Plugins nur am primären Homedir (E78) und in Arbeitsverzeichnissen
-        // außerhalb von WSL (E96): die claude-CLI dieses Rechners kennt die Plugin-Konfiguration einer
-        // WSL-Distro nicht, ihre user-Liste gehörte zum Windows-Home.
+        // Arbeitsverzeichnissen Sekunden. WSL-Ziele fragen die claude-CLI ihrer Distro (E101); ein Ort
+        // ohne erreichbare CLI ergibt eine leere Liste.
         const pluginListen = new Map();
         if (mitPlugins) {
             const abfragen = [];
             for (const { harness, ziele } of plan)
                 if (kannPlugins(harness))
                     for (const ziel of ziele)
-                        if (wslDistroVonOrt(ziel.ort) === undefined)
-                            abfragen.push({
-                                schluessel: zielSchluessel(ziel),
-                                abruf: () => harness.plugins.installierte(ziel).catch(() => []),
-                            });
+                        abfragen.push({
+                            schluessel: zielSchluessel(ziel),
+                            abruf: () => harness.plugins.installierte(ziel).catch(() => []),
+                        });
             const listen = await mitBegrenzung(PLUGIN_ABFRAGEN_GLEICHZEITIG, abfragen.map((a) => a.abruf));
             abfragen.forEach((a, i) => pluginListen.set(a.schluessel, listen[i]));
         }

package/dist/kern/modell.js

@@ -83,6 +83,19 @@ export function wslUncZerlegen(pfad) {
     const rest = (treffer[2] ?? '').split('\\').filter((teil) => teil.length > 0);
     return { distro, linuxPfad: `/${rest.join('/')}` };
 }
+/**
+ * Ein Linux-Pfad der Distro in der UNC-Schreibweise eines vorhandenen WSL-Pfads (E100): Präfix und
+ * Distro kommen aus `vorlage` (so, wie der Nutzer sie geschrieben hat), der Rest aus `linuxPfad`.
+ * So nennt etwa die E91-Meldung eine Git-Wurzel, die sich direkt an `hmgr dir add` geben lässt.
+ * Ist `vorlage` kein WSL-UNC-Pfad: undefined.
+ */
+export function wslUncBilden(vorlage, linuxPfad) {
+    const treffer = /^(\\\\(?:\?\\UNC\\)?(?:wsl\$|wsl\.localhost)\\[^\\]+)/i.exec(vorlage.trim().replaceAll('/', '\\'));
+    if (treffer === null)
+        return undefined;
+    const teile = linuxPfad.split('/').filter((teil) => teil.length > 0);
+    return `${treffer[1]}\\${teile.join('\\')}`;
+}
 /** Die WSL-Distro, über deren Bridge ein Ort bedient wird: ein `wsl:`-Heim (E78) oder ein WSL-UNC-Arbeitsverzeichnis (E96). */
 export function wslDistroVonOrt(ort) {
     if (ort.art === 'home')
@@ -146,34 +159,30 @@ export class HeimUnbekannt extends Error {
     }
 }
 /**
- * Etwas, das nur am primären Homedir geht, wurde für ein zusätzliches verlangt (E78): die
- * claude-CLI dieses Rechners bedient das Windows-Home, nicht das einer WSL-Distro — MCP-Server und
- * Plugins lassen sich dort deshalb nicht verwalten. Skill-Links legt hmgr dort selbst, ohne CLI.
+ * An einem Ort antwortet keine claude-CLI (E100, E101). MCP-Server und Plugins verwaltet hmgr
+ * ausschließlich über die CLI (E16, E61); welche CLI zuständig ist, entscheidet der Ort: unter
+ * Windows die vom PATH, in einem WSL-Heim oder WSL-Arbeitsverzeichnis die der Distro. Gibt es nur
+ * eine von beiden, gehen die Orte der anderen Welt nicht.
  */
-export class HeimOhneCliZugriff extends Error {
-    harness;
-    adresse;
-    constructor(harness, adresse, was) {
-        super(`${harness} kann ${was} im Homedir „${adresse}" nicht verwalten: die claude-CLI dieses Rechners bedient nur ` +
-            'das primäre Homedir. Skill-Links legt hmgr dort selbst.');
-        this.harness = harness;
-        this.adresse = adresse;
-    }
-}
-/**
- * MCP-Server oder Plugins für ein Arbeitsverzeichnis in WSL verlangt (E96): die claude-CLI dieses
- * Rechners schreibt in die Windows-Konfiguration, die das Claude in der Distro nie liest. Skill-Links
- * legt hmgr dort selbst, über die Bridge der Distro.
- */
-export class ArbeitsverzeichnisOhneCliZugriff extends Error {
-    harness;
-    pfad;
-    constructor(harness, pfad, was) {
-        super(`${harness === 'claude-code' ? 'Claude Code' : harness} kann ${was} im Arbeitsverzeichnis „${pfad}" nicht verwalten: ` +
-            'es liegt in WSL, die claude-CLI dieses Rechners schreibt nur in die Windows-Konfiguration. ' +
-            'Skill-Links legt hmgr dort selbst.');
-        this.harness = harness;
-        this.pfad = pfad;
+export class ClaudeCliNichtErreichbar extends Error {
+    ziel;
+    distro;
+    constructor(ziel, distro) {
+        const ort = ziel.ort.art === 'home'
+            ? ziel.ort.heim === undefined
+                ? 'dem Homedir'
+                : `dem Homedir ${ziel.ort.heim}`
+            : ziel.ort.art === 'arbeitsverzeichnis'
+                ? `dem Arbeitsverzeichnis „${ziel.ort.pfad}"`
+                : `dem Profil ${ziel.ort.name}`;
+        super(distro === undefined
+            ? `In ${ort} ist keine claude-CLI erreichbar: auf diesem Rechner liegt keine claude im PATH ` +
+                '(claude --version scheiterte). MCP-Server und Plugins lassen sich dort erst verwalten, wenn Claude Code hier installiert ist.'
+            : `In ${ort} ist keine claude-CLI erreichbar: in der WSL-Distro ${distro} fand hmgr keine ` +
+                '(gesucht mit command -v claude in einer Login-Shell, danach unter ~/.local/bin/claude). ' +
+                'MCP-Server und Plugins lassen sich dort erst verwalten, wenn Claude Code in der Distro installiert ist.');
+        this.ziel = ziel;
+        this.distro = distro;
     }
 }
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hmgr",
-  "version": "0.0.29",
+  "version": "0.0.34",
   "description": "Harness Manager: Skills und Plugins für AI-Harnesses verwalten",
   "license": "MIT",
   "author": "Tim Kaufmann",