hmgr 0.0.26 → 0.0.28

package/dist/adapter/agents.js

@@ -1,22 +1,27 @@
 // Das universelle Skill-Verzeichnis `.agents/skills`: ein Harness-Typ ohne Programm dahinter (E35).
 // Home ist `~/.agents/skills`, das Arbeitsverzeichnis `<pfad>/.agents/skills`.
-import { mkdir, stat } from 'node:fs/promises';
+import { stat } from 'node:fs/promises';
 import path from 'node:path';
 import { OrtNichtUnterstuetzt } from "../kern/modell.js";
 import { gitignoreEintragen, istGitRepo } from "./gitignore.js";
-import { nurHome } from "./heime.js";
+import { LokalerZugriff } from "./dateisystem.js";
+import { arbeitsverzeichnisVerbinden, nurHome } from "./heime.js";
 const AGENTS_VERZEICHNIS = '.agents';
 const SKILLS_ORDNER = 'skills';
 const GITIGNORE_ZEILE = '.agents/';
 export class Agents {
     name = 'agents';
     heime;
+    /** Zugriff je Ort (E96): lokal, für ein Arbeitsverzeichnis in WSL die Bridge der Distro. */
+    zugriffFuer;
     /**
      * `heime` sagt, wo das Homedir liegt (E78, F89): umstellbar, aber ohne zusätzliche Homedirs —
      * die gibt es bisher nur bei claude-code. Ein blanker Pfad steht für „genau dieses Home".
      */
-    constructor(heime) {
+    constructor(heime, zugriffFuer) {
         this.heime = typeof heime === 'string' ? nurHome(heime) : heime;
+        const lokal = new LokalerZugriff();
+        this.zugriffFuer = zugriffFuer ?? (() => lokal);
     }
     get home() {
         return this.heime.primaer(this.name);
@@ -37,11 +42,11 @@ export class Agents {
         if (ort.art === 'home')
             return path.join(this.heime.pfad(this.name, ort), AGENTS_VERZEICHNIS, SKILLS_ORDNER);
         if (ort.art === 'arbeitsverzeichnis')
-            return path.join(ort.pfad, AGENTS_VERZEICHNIS, SKILLS_ORDNER);
+            return arbeitsverzeichnisVerbinden(ort.pfad, AGENTS_VERZEICHNIS, SKILLS_ORDNER);
         throw new OrtNichtUnterstuetzt(this.name, ort.art);
     }
     async vorbereiten(ort) {
-        await mkdir(this.zielVerzeichnis(ort), { recursive: true });
+        await this.zugriffFuer(ort).verzeichnisAnlegen(this.zielVerzeichnis(ort));
         // .agents/ darf nicht ins Repo (B7).
         if (ort.art === 'arbeitsverzeichnis' && (await istGitRepo(ort.pfad)))
             await gitignoreEintragen(ort.pfad, GITIGNORE_ZEILE);

package/dist/adapter/claude-code.js

@@ -3,11 +3,11 @@ import spawn from 'cross-spawn';
 import { realpathSync } from 'node:fs';
 import { readFile, stat } from 'node:fs/promises';
 import path from 'node:path';
-import { HeimOhneCliZugriff, McpAbweichenderEintrag, McpNichtInGeteilterDatei, McpNurGeteilterFundort, McpUebernahmeNichtMoeglich, McpUebernahmeUnvollstaendig, OrtNichtUnterstuetzt, pluginSchluessel, } from "../kern/modell.js";
+import { ArbeitsverzeichnisOhneCliZugriff, HeimOhneCliZugriff, McpAbweichenderEintrag, McpNichtInGeteilterDatei, McpNurGeteilterFundort, McpUebernahmeNichtMoeglich, McpUebernahmeUnvollstaendig, OrtNichtUnterstuetzt, pluginSchluessel, wslUncZerlegen, } from "../kern/modell.js";
 import { ohneBom } from "./datei-text.js";
 import { LokalerZugriff } from "./dateisystem.js";
 import { gitignoreEintragen, istGitRepo } from "./gitignore.js";
-import { heimVerbinden, nurHome } from "./heime.js";
+import { arbeitsverzeichnisVerbinden, heimVerbinden, nurHome } from "./heime.js";
 import { tiefGleich } from "./vergleich.js";
 const CLAUDE_VERZEICHNIS = '.claude';
 const SKILLS_ORDNER = 'skills';
@@ -19,6 +19,17 @@ const SKILLS_ORDNER = 'skills';
 function zusaetzlichesHeim(ort) {
     return ort.art === 'home' ? ort.heim : undefined;
 }
+/**
+ * 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);
+}
 const GITIGNORE_ZEILE = '.claude/';
 /**
  * Standard-Ausführer: `claude` vom PATH. Ein Fehlschlag wird zum Code, nicht zur Ausnahme.
@@ -125,9 +136,7 @@ class ClaudePlugins {
      * Startverzeichnis ab, mit dem Zielverzeichnis als cwd landete sie unter `.claude/skills/`.
      */
     scope(ziel) {
-        const heim = zusaetzlichesHeim(ziel.ort);
-        if (heim !== undefined)
-            throw new HeimOhneCliZugriff(this.harness.name, heim, 'Plugins');
+        ohneCliZugriffPruefen(this.harness.name, ziel.ort, 'Plugins');
         if (ziel.ort.art === 'home')
             return { scope: 'user' };
         if (ziel.ort.art === 'arbeitsverzeichnis')
@@ -249,9 +258,7 @@ class ClaudeMcp {
         return 'Claude Code übernimmt die Änderung mit der nächsten Sitzung.';
     }
     scope(ort) {
-        const heim = zusaetzlichesHeim(ort);
-        if (heim !== undefined)
-            throw new HeimOhneCliZugriff(this.harness.name, heim, 'MCP-Server');
+        ohneCliZugriffPruefen(this.harness.name, ort, 'MCP-Server');
         if (ort.art === 'home')
             return { scope: 'user' };
         if (ort.art === 'arbeitsverzeichnis')
@@ -308,6 +315,9 @@ class ClaudeMcp {
     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);
         return Object.keys(server).map((name) => ({ name, datei, scope: 'project' }));
@@ -331,6 +341,7 @@ 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];
         if (block === undefined)
@@ -366,9 +377,7 @@ class ClaudeMcp {
      * die MCP-Operationen, bevor sie den Adapter erreichen.
      */
     async mcpServersAm(ort) {
-        const heim = zusaetzlichesHeim(ort);
-        if (heim !== undefined)
-            throw new HeimOhneCliZugriff(this.harness.name, heim, 'MCP-Server');
+        ohneCliZugriffPruefen(this.harness.name, ort, 'MCP-Server');
         const daten = await this.claudeJsonLesen();
         if (ort.art === 'home')
             return mcpServersVon(daten);
@@ -442,13 +451,15 @@ export class ClaudeCode {
         if (ort.art === 'home')
             return heimVerbinden(ort, this.heime.pfad(this.name, ort), CLAUDE_VERZEICHNIS, SKILLS_ORDNER);
         if (ort.art === 'arbeitsverzeichnis')
-            return path.join(ort.pfad, CLAUDE_VERZEICHNIS, SKILLS_ORDNER);
+            return arbeitsverzeichnisVerbinden(ort.pfad, CLAUDE_VERZEICHNIS, SKILLS_ORDNER);
         throw new OrtNichtUnterstuetzt(this.name, ort.art);
     }
     async vorbereiten(ort) {
         // Über den Zugriff, nicht über `mkdir`: in einem WSL-Heim liegt das Verzeichnis im
         // Linux-Dateisystem, wo Windows-Node nicht anlegen kann (E78).
         await this.zugriffFuer(ort).verzeichnisAnlegen(this.zielVerzeichnis(ort));
+        // `.git` und `.gitignore` sind gewöhnliche Dateien im Arbeitsverzeichnis und bleiben auch bei
+        // einem WSL-Pfad über den Share unter `ort.pfad` erreichbar, nicht über den Linux-Pfad (E96).
         if (ort.art === 'arbeitsverzeichnis' && (await istGitRepo(ort.pfad)))
             await gitignoreEintragen(ort.pfad, GITIGNORE_ZEILE);
     }

package/dist/adapter/dateisystem.js

@@ -51,6 +51,9 @@ export function linkFehlerHinweis(plattform = process.platform) {
  */
 export class LokalerZugriff {
     trenner = path.sep;
+    linkFehlerHinweis() {
+        return linkFehlerHinweis();
+    }
     verbinden(verzeichnis, name) {
         return path.join(verzeichnis, name);
     }
@@ -213,7 +216,7 @@ export class DateisystemZiele {
             await zugriff.linkAnlegen(pfad, checkoutZiel);
         }
         catch (ursache) {
-            throw new LinkAnlegenFehlgeschlagen(pfad, checkoutZiel, ursache instanceof Error ? ursache.message : String(ursache), linkFehlerHinweis());
+            throw new LinkAnlegenFehlgeschlagen(pfad, checkoutZiel, ursache instanceof Error ? ursache.message : String(ursache), zugriff.linkFehlerHinweis());
         }
     }
     async linkEntfernen(ziel, verzeichnis, name) {

package/dist/adapter/heime.js

@@ -1,6 +1,6 @@
 // Homedirs eines Harness aus dem Zustand (E78). Synchron, siehe HeimePort.
 import path from 'node:path';
-import { HeimUnbekannt, OrtNichtUnterstuetzt, heimAdresseZerlegen } from "../kern/modell.js";
+import { HeimUnbekannt, OrtNichtUnterstuetzt, heimAdresseZerlegen, wslUncZerlegen } from "../kern/modell.js";
 /**
  * Pfade in der Welt eines Homedirs zusammensetzen (E78): POSIX in einer WSL-Distro, sonst die
  * Schreibweise des Betriebssystems. Ohne das ergäbe `path.join` unter Windows `\`-Pfade für ein
@@ -12,6 +12,14 @@ export function heimVerbinden(ort, ...teile) {
         ? path.posix.join(...teile)
         : path.join(...teile);
 }
+/**
+ * Pfad unterhalb eines Arbeitsverzeichnisses (E96). Liegt es in WSL (`\\wsl$\<distro>\…`), kommt der
+ * POSIX-Pfad in der Distro heraus, den die Bridge bedient; sonst `path.join` am gespeicherten Pfad.
+ */
+export function arbeitsverzeichnisVerbinden(pfad, ...teile) {
+    const wsl = wslUncZerlegen(pfad);
+    return wsl !== undefined ? path.posix.join(wsl.linuxPfad, ...teile) : path.join(pfad, ...teile);
+}
 /**
  * Ob eine Adresse auf dieser Plattform bedienbar ist (E78, Entscheidung 7). `wsl:`-Heime gibt es
  * nur unter Windows; steht eines im Zustand, weil er von einem Windows-Rechner stammt, wird sein

package/dist/adapter/hermes.js

@@ -6,7 +6,8 @@ import path from 'node:path';
 import { Document, isMap, isScalar, isSeq, parseDocument } from 'yaml';
 import { McpAbweichenderEintrag, OrtNichtUnterstuetzt, SkillOrdnerUngueltig, } from "../kern/modell.js";
 import { gitignoreEintragen, istGitRepo } from "./gitignore.js";
-import { nurHome } from "./heime.js";
+import { LokalerZugriff } from "./dateisystem.js";
+import { arbeitsverzeichnisVerbinden, nurHome } from "./heime.js";
 import { tiefGleich } from "./vergleich.js";
 const HERMES_VERZEICHNIS = '.hermes';
 const PROFILE_VERZEICHNIS = 'profiles';
@@ -70,6 +71,8 @@ function mcpKonfigAlsObjekt(konfig) {
 export class Hermes {
     name = 'hermes';
     heime;
+    /** Zugriff je Ort (E96): lokal, für ein Arbeitsverzeichnis in WSL die Bridge der Distro. */
+    zugriffFuer;
     /**
      * MCP-Server (E61): nur Home und Profil, denn Hermes kennt keine Projektebene für MCPs. Bindung
      * über Arrow-Funktionen auf `this`, damit die Fähigkeit ohne eigene Klasse auskommt.
@@ -86,8 +89,10 @@ export class Hermes {
      * Hermes' Zielverzeichnis steht in einer config.yaml; die über die Bridge zu lesen und zu
      * schreiben wäre ein eigener Schnitt. Ein blanker Pfad steht für „genau dieses Home".
      */
-    constructor(heime) {
+    constructor(heime, zugriffFuer) {
         this.heime = typeof heime === 'string' ? nurHome(heime) : heime;
+        const lokal = new LokalerZugriff();
+        this.zugriffFuer = zugriffFuer ?? (() => lokal);
     }
     get home() {
         return this.heime.primaer(this.name);
@@ -155,7 +160,7 @@ export class Hermes {
     }
     zielVerzeichnis(ort) {
         if (ort.art === 'arbeitsverzeichnis')
-            return path.join(ort.pfad, HERMES_VERZEICHNIS, EIGENER_ORDNER);
+            return arbeitsverzeichnisVerbinden(ort.pfad, HERMES_VERZEICHNIS, EIGENER_ORDNER);
         const hermesHome = this.hermesHome(ort);
         return this.ersterEintrag(hermesHome) ?? path.join(hermesHome, STANDARD_ORDNER);
     }
@@ -246,13 +251,15 @@ export class Hermes {
     }
     async vorbereiten(ort) {
         const verzeichnis = this.zielVerzeichnis(ort);
-        await mkdir(verzeichnis, { recursive: true });
         if (ort.art === 'arbeitsverzeichnis') {
+            // Über den Zugriff: in einem WSL-Arbeitsverzeichnis legt die Bridge der Distro es an (E96).
+            await this.zugriffFuer(ort).verzeichnisAnlegen(verzeichnis);
             // .hermes/ darf nicht ins Repo (B7).
             if (await istGitRepo(ort.pfad))
                 await gitignoreEintragen(ort.pfad, GITIGNORE_ZEILE);
             return;
         }
+        await mkdir(verzeichnis, { recursive: true });
         await this.registrieren(this.hermesHome(ort), verzeichnis);
     }
     /** Trägt das Verzeichnis in skills.external_dirs ein, falls es fehlt. Kommentare bleiben erhalten. */

package/dist/adapter/wsl.js

@@ -151,6 +151,9 @@ export class WslZugriff {
     constructor(bruecke) {
         this.bruecke = bruecke;
     }
+    linkFehlerHinweis() {
+        return `Prüfe, ob die Distro ${this.bruecke.distro} läuft und das Linkziel unter /mnt/c erreichbar ist.`;
+    }
     verbinden(verzeichnis, name) {
         return path.posix.join(verzeichnis, name);
     }

package/dist/cli/hilfe.js

@@ -104,6 +104,11 @@ Plugins des Vorhabens stehen. Ohne Zeiger bleibt das Verzeichnis gemerkt und jed
 (E26). dir forget löst Bindung und Eintrag, die gelegten Links bleiben liegen. Gebunden wird nur für
 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.
+
 Schalter:
   --composer <pfad>   nur bei add: composer.json wählen, wenn unter dem Verzeichnis mehrere in
                       Frage kommen
@@ -623,6 +628,8 @@ Links dort legt hmgr über wsl.exe an; das Linkziel bleibt der vorhandene Window
 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.
 
+Ein Arbeitsverzeichnis unter \\\\wsl$\\<distro>\\… bedient hmgr ebenso über die Distro (hmgr help dir, E96).
+
 Zusätzliche Homedirs kennt bisher nur claude-code, und nur unter Windows. Steht eines im Zustand,
 etwa weil er von einem Windows-Rechner kommt, zeigt hmgr sein Ziel auf anderen Plattformen nicht.
 

package/dist/cli/main.js

@@ -5,7 +5,7 @@ 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, 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, pluginSchluessel, quelleName, quelleSchluessel, } from "../kern/modell.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 { Agents } from "../adapter/agents.js";
 import { ClaudeCode, claudeAusfuehrer } from "../adapter/claude-code.js";
 import { Hermes } from "../adapter/hermes.js";
@@ -53,13 +53,14 @@ export function bauen(umgebung, optionen = {}) {
     };
     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));
+        // Ein WSL-Heim (E78) und ein Arbeitsverzeichnis unter \\wsl$\<distro> (E96) gehen über die
+        // Bridge ihrer Distro; alles andere über das lokale Dateisystem.
+        const distro = wslDistroVonOrt(ort);
+        return distro === undefined ? lokal : new WslZugriff(bruecke(distro));
     };
     const claude = new ClaudeCode(heime, optionen.claudeAusfuehrer ?? claudeAusfuehrer, zugriffFuerOrt);
     const ports = {
-        harnesses: [claude, new Hermes(heime), new Agents(heime)],
+        harnesses: [claude, new Hermes(heime, zugriffFuerOrt), new Agents(heime, zugriffFuerOrt)],
         quellen: new GitQuellen(wurzel),
         ziele: new DateisystemZiele(wurzel, zustand, umgebung.xdgStateHome, (ziel) => zugriffFuerOrt(ziel.ort)),
         zeiger: new ComposerZeiger(),
@@ -1152,6 +1153,7 @@ function istModellFehler(fehler) {
         fehler instanceof HeimFaehigkeitFehlt ||
         fehler instanceof HeimNurUnterWindows ||
         fehler instanceof HeimOhneCliZugriff ||
+        fehler instanceof ArbeitsverzeichnisOhneCliZugriff ||
         fehler instanceof HeimUnbekannt ||
         fehler instanceof WslBrueckeFehlgeschlagen);
 }
@@ -1204,6 +1206,8 @@ 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 WslBrueckeFehlgeschlagen)

package/dist/gui/hmgr-cli.js

@@ -1,8 +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 { homedir } from 'node:os';
+import path from 'node:path';
 import spawn from 'cross-spawn';
 import { versionLesen } from "../kern/version.js";
+/**
+ * Zeigt der aufgelöste Treffer auf die laufende GUI selbst (E97)? Deren Electron-exe heißt ebenfalls
+ * `hmgr.exe`; eine zweite Instanz endet an der Einzelinstanz-Sperre ohne Ausgabe und würde als
+ * „CLI vor 0.0.7" gelten. Unter win32 ohne Rücksicht auf Groß-/Kleinschreibung.
+ */
+export function istEigeneGui(aufgeloest, execPath, plattform) {
+    if (!aufgeloest)
+        return false;
+    const a = path.resolve(aufgeloest);
+    const b = path.resolve(execPath);
+    return plattform === 'win32' ? a.toLowerCase() === b.toLowerCase() : a === b;
+}
+/**
+ * Spawn-Optionen der CLI-Abfrage. Festes `cwd` (E97): `which` sucht unter Windows zuerst im
+ * Arbeitsverzeichnis, und cross-spawn wechselt für die Suche in genau dieses `cwd` — läge es im
+ * Installationsordner der GUI, würde die eigene `hmgr.exe` statt der CLI gefunden.
+ */
+export function cliSpawnOptionen(heim = homedir()) {
+    return {
+        stdio: ['ignore', 'pipe', 'ignore'],
+        timeout: 10_000,
+        killSignal: 'SIGKILL',
+        cwd: heim,
+    };
+}
+/**
+ * Der Pfad, den cross-spawn für `hmgr` starten würde. `_parse` setzt `file` nur unter win32 (in
+ * parse.js `parseNonShell`, nur dort wird aufgelöst); sonst bleibt es `undefined`. `file` ist der
+ * aufgelöste Pfad vor einer Umsetzung auf cmd.exe oder Shebang, also der Treffer von `which`.
+ */
+function aufgeloesterPfad(optionen) {
+    const geparst = spawn._parse('hmgr', ['--version'], optionen);
+    return geparst.file;
+}
 /**
  * `hmgr --version` (E72: nur die Nummer, Exit 0). Kein Fehler dringt nach außen — der Aufrufer
  * entscheidet anhand des Befunds, was zu melden ist.
@@ -22,11 +58,11 @@ export function hmgrCliVersion() {
             aufloesen(wert);
         };
         try {
-            const kind = spawn('hmgr', ['--version'], {
-                stdio: ['ignore', 'pipe', 'ignore'],
-                timeout: 10_000,
-                killSignal: 'SIGKILL',
-            });
+            const optionen = cliSpawnOptionen();
+            if (istEigeneGui(aufgeloesterPfad(optionen), process.execPath, process.platform)) {
+                return melden({ art: 'fehlt' });
+            }
+            const kind = spawn('hmgr', ['--version'], optionen);
             let stdout = '';
             kind.stdout.on('data', (stueck) => (stdout += stueck));
             kind.on('error', () => melden({ art: 'fehlt' }));

package/dist/gui/main.js

@@ -886,6 +886,35 @@ function fensterOeffnen() {
               } catch (fehler) {
                 bundleZerbrichtText = String(fehler);
               }
+              // Sammelstreifen unter „Alle" (E95): das Bundle „vorhaben" liegt an kunde-x in Claude Code
+              // und Hermes — ein Streifen mit beiden Harness-Zeichen, Entfernen nennt beide Harnesses
+              // (nur der Dialogtext, kein Klick auf „Ja"). Unter dem Harness-Chip steht weiter die
+              // volle Gruppe mit Zeilen; danach zurück auf „Alle".
+              var streifenKarte = Array.from(document.querySelectorAll('#zielliste .ziel.verzeichnis'))
+                .find((k) => (k.querySelector('.zielkopf')?.textContent || '').indexOf('kunde-x') > -1);
+              var streifenZahl = null, streifenHarnesse = null, streifenText = null;
+              var streifenDialogTitel = null, streifenDialogText = null;
+              var chipGruppeZahl = null, chipGruppeZeilenZahl = null, chipStreifenZahl = null;
+              try {
+                var streifen = Array.from(streifenKarte?.querySelectorAll('.bundlegruppe') ?? []);
+                streifenZahl = streifen.length;
+                streifenHarnesse = streifen[0]?.querySelector('.zeilenzeichen')?.getAttribute('aria-label') ?? null;
+                streifenText = streifen[0]?.textContent?.replace(/\\s+/g, ' ').trim() ?? null;
+                streifen[0]?.querySelector('button')?.click();
+                streifenDialogTitel = document.getElementById('dx-titel')?.textContent ?? null;
+                streifenDialogText = document.getElementById('dx-text')?.textContent ?? null;
+                document.querySelector('#d-entfernen button[value="nein"]')?.click();
+                var chipClaude = streifenKarte?.querySelector('.kartenchips [data-chipwahl="claude-code"]');
+                chipClaude?.click();
+                var kundeXNachChip = Array.from(document.querySelectorAll('#zielliste .ziel.verzeichnis'))
+                  .find((k) => (k.querySelector('.zielkopf')?.textContent || '').indexOf('kunde-x') > -1);
+                chipGruppeZahl = kundeXNachChip?.querySelectorAll('.bundlegruppe').length ?? null;
+                chipGruppeZeilenZahl = kundeXNachChip?.querySelectorAll('.bundlegruppe .linkliste li').length ?? null;
+                chipStreifenZahl = kundeXNachChip?.querySelectorAll('.bundlegruppe .zeilenzeichen').length ?? null;
+                kundeXNachChip?.querySelector('.kartenchips [data-chipwahl="alle"]')?.click();
+              } catch (fehler) {
+                streifenDialogText = String(fehler);
+              }
               // MCP-Ansicht (E61-Folgerunde, F46: abgespeckt zum reinen Katalog): Navigationsreihenfolge
               // Ziele, MCP, Plugins, Skills, Karten mit Name/Beschreibung/Homepage-Link, F39-Warnzeile,
               // Einhängen-Dialog öffnen/abbrechen ohne IPC-Schreibaktion. Orte-Liste und Fremdkasten
@@ -1172,6 +1201,14 @@ function fensterOeffnen() {
                 bundleGruppeText,
                 bundleGruppeZeilen,
                 bundleZerbrichtText,
+                streifenZahl,
+                streifenHarnesse,
+                streifenText,
+                streifenDialogTitel,
+                streifenDialogText,
+                chipGruppeZahl,
+                chipGruppeZeilenZahl,
+                chipStreifenZahl,
                 interGeladen: document.fonts.check('400 16px Inter'),
                 monoGeladen: document.fonts.check('500 16px "JetBrains Mono"'),
                 quelleneuVorhanden,

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.</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. Arbeitsverzeichnisse in WSL (\\wsl$\…) gehen dort nicht: die claude-CLI dieses Rechners kennt ihre Konfiguration nicht.</p>
         </div>
 
         <div class="mcpliste" id="mcpliste"></div>
@@ -345,7 +345,7 @@
     <div class="dkopf">
       <span class="etikett">Homedir in WSL</span>
       <h3>Welche Distro?</h3>
-      <p>Claude Code in einer WSL-Distro hat ein eigenes Homedir. hmgr ermittelt es einmal, zeigt es an und legt Links dort über wsl.exe an; die Checkouts bleiben, wo sie sind. Das Ziel steht danach als eigene Karte neben dem Windows-Homedir, gespiegelt wird nichts.</p>
+      <p>Claude Code in einer WSL-Distro hat ein eigenes Homedir. hmgr ermittelt es einmal, zeigt es an und legt Links dort über wsl.exe an; die Checkouts bleiben, wo sie sind. Das Ziel steht danach als eigene Karte neben dem Windows-Homedir, gespiegelt wird nichts. Ein Arbeitsverzeichnis unter \\wsl$\… bedient hmgr ebenfalls über die Distro, ohne dass du hier etwas eintragen musst.</p>
     </div>
     <div class="dkoerper">
       <div class="feld">

package/dist/gui/renderer/renderer.js

@@ -826,21 +826,35 @@
     return gruppe;
   }
 
-  /** Ein Bundle als einzelner Streifen (Chip „Alle" einer Verzeichnis-Karte, E69/E53): Harness-
-      Zeichen, Name, seine Mitglieder als Text, Entfernen. Ohne eigene Tabelle. */
-  function bundleStreifen(b, z) {
+  /** Ein Bundle als einzelner Streifen (Chip „Alle" einer Verzeichnis-Karte, E69/E53/E95): die
+      Harness-Zeichen aller Harnesses, in denen es liegt (wie in den Skill-Zeilen), Name, Mitglieder,
+      Entfernen für alle diese Harnesses. `treffer`: [{b, z}], je Harness einer, gleicher Name und
+      gleiche Quelle. Mitglieder: die des ersten Treffers, abweichende anderer Harnesses folgen. */
+  function bundleStreifen(treffer) {
+    var b = treffer[0].b;
     var streifen = e('div', 'bundlegruppe');
     var kopf = e('div', 'bundlekopf');
     var titel = e('span', 'bundletitel');
-    titel.appendChild(harnessZeichen(z.ziel.harness));
+    var harnesse = [];
+    treffer.forEach(function (t) { if (harnesse.indexOf(t.z.ziel.harness) === -1) harnesse.push(t.z.ziel.harness); });
+    harnesse.sort(function (x, y) { return harnessName(x).localeCompare(harnessName(y), 'de'); });
+    titel.appendChild(harnesseZeichenSammel(harnesse));
     titel.appendChild(e('span', 'etikett', 'Bundle'));
     titel.appendChild(e('b', 'bundlename', b.name));
     kopf.appendChild(titel);
-    kopf.appendChild(e('span', 'bundlemitglieder', b.skills.join(', ')));
+    var mitglieder = [];
+    treffer.forEach(function (t) {
+      t.b.skills.forEach(function (n) { if (mitglieder.indexOf(n) === -1) mitglieder.push(n); });
+    });
+    kopf.appendChild(e('span', 'bundlemitglieder', mitglieder.join(', ')));
     var weg = e('button', 'knopf leise klein', 'Entfernen');
     weg.type = 'button';
-    weg.setAttribute('aria-label', 'Bundle ' + b.name + ' aus ' + zielTitel(z) + ' entfernen');
-    weg.addEventListener('click', function () { frageBundleEntfernen(b, z.ziel); });
+    weg.setAttribute('aria-label', 'Bundle ' + b.name + ' aus '
+      + treffer.map(function (t) { return zielTitel(t.z); }).join(', ') + ' entfernen');
+    weg.addEventListener('click', function () {
+      if (treffer.length === 1) frageBundleEntfernen(b, treffer[0].z.ziel);
+      else frageBundleEntfernenAlle(b.name, mitglieder, treffer);
+    });
     kopf.appendChild(weg);
     streifen.appendChild(kopf);
     return streifen;
@@ -1209,13 +1223,22 @@
     // Bundle gehört aber zu genau einem Harness — deshalb hier ein Streifen je Bundle mit seinem
     // Harness-Zeichen statt einer Umgruppierung der Tabelle. Unter dem Harness-Chip zeigt linkTeil
     // die volle Gruppe über den Zeilen.
+    // Ein Bundle, das in mehreren Harnesses am selben Ort liegt, ist hier ein Streifen (E95), wie
+    // die Skill-Zeilen: Schlüssel ist Name plus Quelle, gleichnamige Bundles aus zwei Quellen
+    // bleiben getrennt.
+    var bundleGruppen = {}, bundleReihenfolge = [];
     teile.forEach(function (z) {
       (z.bundles || [])
         .filter(function (b) { return b.skills.length > 0; })
-        .slice()
-        .sort(function (a, b) { return a.name.localeCompare(b.name, 'de'); })
-        .forEach(function (b) { teil.appendChild(bundleStreifen(b, z)); });
+        .forEach(function (b) {
+          var schluessel = b.name + '\u0000' + b.quelleText;
+          if (!bundleGruppen[schluessel]) { bundleGruppen[schluessel] = []; bundleReihenfolge.push(schluessel); }
+          bundleGruppen[schluessel].push({ b: b, z: z });
+        });
     });
+    bundleReihenfolge
+      .sort(function (a, b) { return bundleGruppen[a][0].b.name.localeCompare(bundleGruppen[b][0].b.name, 'de'); })
+      .forEach(function (k) { teil.appendChild(bundleStreifen(bundleGruppen[k])); });
 
     var kopf = e('div', 'linkkopf');
     kopf.appendChild(e('span'));
@@ -1612,12 +1635,24 @@
 
   /** Entfernen des ganzen Bundles an einem Ziel (E69): alle seine Links auf einmal. */
   function frageBundleEntfernen(b, ziel) {
-    entfernenKontext = { art: 'bundle', bundle: b.name, ziel: ziel };
+    entfernenKontext = { art: 'bundle', bundle: b.name, ziele: [ziel] };
     $('dx-titel').textContent = 'Bundle ' + b.name + ' entfernen?';
     $('dx-text').textContent = zahlwort(b.skills.length, 'Link', 'Links') + ' aus ' + zielTitel({ ziel: ziel })
       + ' verschwinden: ' + b.skills.join(', ') + '. Die Checkouts bleiben liegen, bis kein Link mehr darauf zeigt.';
     zeige($('d-entfernen'));
   }
+  /** Entfernen eines Bundles in allen Harnesses seines Streifens (E95): `treffer` wie bei
+      bundleStreifen, der Dialog nennt die Harnesses mit ihrer Linkzahl und die Mitglieder. */
+  function frageBundleEntfernenAlle(name, mitglieder, treffer) {
+    entfernenKontext = { art: 'bundle', bundle: name, ziele: treffer.map(function (t) { return t.z.ziel; }) };
+    var proHarness = treffer.map(function (t) {
+      return harnessName(t.z.ziel.harness) + ' ' + zahlwort(t.b.skills.length, 'Link', 'Links');
+    });
+    $('dx-titel').textContent = 'Bundle ' + name + ' entfernen?';
+    $('dx-text').textContent = 'Das Bundle verschwindet in ' + treffer.length + ' Harnesses (' + proHarness.join(', ')
+      + '): ' + mitglieder.join(', ') + '. Die Checkouts bleiben liegen, bis kein Link mehr darauf zeigt.';
+    zeige($('d-entfernen'));
+  }
   /** Entfernen einer „Alle"-Zeile (E53 Pkt. 2): entfernbareZiele sind die Ziele (voller z.ziel), in
       denen der Link weg soll, nichtEntfernbareHarnesse die, in denen er nur über ein Plugin hängt
       und liegen bleibt. Der Dialog nennt beides. */
@@ -1640,17 +1675,29 @@
   nachDialog($('d-entfernen'), async function (wert) {
     if (wert !== 'ja' || entfernenKontext === null) return;
     var kontext = entfernenKontext;
-    // Bundle als Ganzes (E69): ein Aufruf, der Kern nimmt alle Links des Bundles weg.
+    // Bundle als Ganzes (E69): je Ziel ein Aufruf, der Kern nimmt alle Links des Bundles weg. Bei
+    // mehreren Zielen (E95) hält ein Fehlschlag die übrigen nicht auf, rufe meldet ihn selbst.
     if (kontext.art === 'bundle') {
-      var wegB = await rufe(function () {
-        return window.hmgr.bundleEntfernen({
-          bundle: kontext.bundle,
-          harness: kontext.ziel.harness,
-          ort: kontext.ziel.ort,
-        });
-      });
+      var entferntB = 0;
+      var gescheitertB = [];
+      for (var j = 0; j < kontext.ziele.length; j++) {
+        var zielB = kontext.ziele[j];
+        try {
+          var wegB = await rufe(function () {
+            return window.hmgr.bundleEntfernen({ bundle: kontext.bundle, harness: zielB.harness, ort: zielB.ort });
+          });
+          entferntB += wegB.entfernt.length;
+        } catch (fehler) {
+          gescheitertB.push(harnessName(zielB.harness));
+        }
+      }
       await ladeAlles();
-      melde('Bundle ' + kontext.bundle + ' entfernt, ' + zahlwort(wegB.entfernt.length, 'Link', 'Links') + ' weniger.');
+      if (gescheitertB.length === 0) {
+        melde('Bundle ' + kontext.bundle + ' entfernt, ' + zahlwort(entferntB, 'Link', 'Links') + ' weniger.');
+      } else if (kontext.ziele.length > 1) {
+        melde('Bundle ' + kontext.bundle + ' blieb in ' + gescheitertB.join(', ') + ' liegen, '
+          + zahlwort(entferntB, 'Link', 'Links') + ' weniger.');
+      }
       return;
     }
     // Ein Fehlschlag in einem Harness hält die übrigen nicht auf: rufe hat ihn schon gemeldet, die

package/dist/kern/anwendungsfaelle.js

@@ -1,6 +1,6 @@
 // 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, 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, 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";
@@ -471,9 +471,11 @@ export class Anwendungsfaelle {
             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)
-                    ziele.push(arbeitsverzeichnisZiel(harness.name, pfad));
+                    if (wslUncZerlegen(pfad) === undefined)
+                        ziele.push(arbeitsverzeichnisZiel(harness.name, pfad));
         }
         return ziele;
     }
@@ -2363,16 +2365,16 @@ 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): die claude-CLI dieses
-        // Rechners kennt die Plugin-Konfiguration einer WSL-Distro nicht, ihre user-Liste gehörte zum
-        // Windows-Home.
+        // 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.
         const pluginListen = new Map();
         if (mitPlugins) {
             const abfragen = [];
             for (const { harness, ziele } of plan)
                 if (kannPlugins(harness))
                     for (const ziel of ziele)
-                        if (!(ziel.ort.art === 'home' && ziel.ort.heim !== undefined))
+                        if (wslDistroVonOrt(ziel.ort) === undefined)
                             abfragen.push({
                                 schluessel: zielSchluessel(ziel),
                                 abruf: () => harness.plugins.installierte(ziel).catch(() => []),

package/dist/kern/modell.js

@@ -68,6 +68,29 @@ export function heimAdresseZerlegen(text) {
         return undefined;
     return { art: 'wsl', distro };
 }
+/**
+ * Zerlegt einen WSL-UNC-Pfad (E96): `\\wsl$\<distro>\…` oder `\\wsl.localhost\<distro>\…`, auch mit
+ * `\\?\UNC\`-Präfix und mit Schrägstrichen in beiden Richtungen. Der Hostteil gilt ohne Rücksicht
+ * auf Groß-/Kleinschreibung, der Distro-Name bleibt unverändert. `linuxPfad` ist der Pfad in der
+ * Distro, absolut und ohne abschließenden Trenner. Alles andere ergibt undefined. Rein und
+ * plattformunabhängig, damit auch Tests außerhalb von Windows ihn abdecken.
+ */
+export function wslUncZerlegen(pfad) {
+    const treffer = /^\\\\(?:\?\\UNC\\)?(?:wsl\$|wsl\.localhost)\\([^\\]+)(?:\\(.*))?$/i.exec(pfad.trim().replaceAll('/', '\\'));
+    if (treffer === null)
+        return undefined;
+    const distro = treffer[1];
+    const rest = (treffer[2] ?? '').split('\\').filter((teil) => teil.length > 0);
+    return { distro, linuxPfad: `/${rest.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')
+        return ort.heim === undefined ? undefined : heimAdresseZerlegen(ort.heim)?.distro;
+    if (ort.art === 'arbeitsverzeichnis')
+        return wslUncZerlegen(ort.pfad)?.distro;
+    return undefined;
+}
 /** Die Adresse eines zusätzlichen Heims in der Schreibweise, die hmgr speichert und anzeigt. */
 export function heimAdresseAlsText(adresse) {
     return `wsl:${adresse.distro}`;
@@ -137,6 +160,22 @@ export class HeimOhneCliZugriff extends Error {
         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;
+    }
+}
 /**
  * Die Bridge in eine WSL-Distro hat nicht geantwortet (E78): die Distro gibt es nicht, sie startet
  * nicht, oder wsl.exe fehlt. Die Ausgabe von wsl.exe steht mit in der Meldung — sie nennt den Grund

package/package.json

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