hmgr 0.0.7 → 0.0.14

package/dist/adapter/agents.js

@@ -4,15 +4,22 @@ import { mkdir, 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";
 const AGENTS_VERZEICHNIS = '.agents';
 const SKILLS_ORDNER = 'skills';
 const GITIGNORE_ZEILE = '.agents/';
 export class Agents {
     name = 'agents';
-    home;
-    /** `home` ist das HOME des Nutzers, das Verzeichnis liegt darunter als `.agents`. */
-    constructor(home) {
-        this.home = home;
+    heime;
+    /**
+     * `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) {
+        this.heime = typeof heime === 'string' ? nurHome(heime) : heime;
+    }
+    get home() {
+        return this.heime.primaer(this.name);
     }
     /**
      * Wie bei den anderen Harness-Typen zählt das angelegte Verzeichnis. Legt es niemand an, gibt es
@@ -25,8 +32,10 @@ export class Agents {
         return ['home', 'arbeitsverzeichnis'];
     }
     zielVerzeichnis(ort) {
+        // Über `heime.pfad` statt über `this.home`: nennt der Ort ein zusätzliches Homedir, wirft der
+        // Port (E78). agents hat die Fähigkeit nicht, ein solcher Ort dürfte hier gar nicht ankommen.
         if (ort.art === 'home')
-            return path.join(this.home, AGENTS_VERZEICHNIS, SKILLS_ORDNER);
+            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);
         throw new OrtNichtUnterstuetzt(this.name, ort.art);

package/dist/adapter/claude-code.js

@@ -1,12 +1,24 @@
 // Claude Code: Grundverhalten plus Plugins und MCP-Server über die claude-CLI (E16, E24, E27, E61).
 import spawn from 'cross-spawn';
 import { realpathSync } from 'node:fs';
-import { mkdir, readFile, stat } from 'node:fs/promises';
+import { readFile, stat } from 'node:fs/promises';
 import path from 'node:path';
-import { McpAbweichenderEintrag, McpNichtInGeteilterDatei, McpNurGeteilterFundort, McpUebernahmeNichtMoeglich, McpUebernahmeUnvollstaendig, OrtNichtUnterstuetzt, pluginSchluessel, } from "../kern/modell.js";
+import { HeimOhneCliZugriff, McpAbweichenderEintrag, McpNichtInGeteilterDatei, McpNurGeteilterFundort, McpUebernahmeNichtMoeglich, McpUebernahmeUnvollstaendig, OrtNichtUnterstuetzt, pluginSchluessel, } 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 { tiefGleich } from "./vergleich.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;
+}
 const GITIGNORE_ZEILE = '.claude/';
 /**
  * Standard-Ausführer: `claude` vom PATH. Ein Fehlschlag wird zum Code, nicht zur Ausnahme.
@@ -113,6 +125,9 @@ 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');
         if (ziel.ort.art === 'home')
             return { scope: 'user' };
         if (ziel.ort.art === 'arbeitsverzeichnis')
@@ -219,6 +234,7 @@ async function projektMcpJsonLesen(verzeichnis) {
 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) {
         this.harness = harness;
@@ -232,6 +248,9 @@ 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');
         if (ort.art === 'home')
             return { scope: 'user' };
         if (ort.art === 'arbeitsverzeichnis')
@@ -343,6 +362,9 @@ class ClaudeMcp {
      * sich Arbeitsverzeichnisse aber so, wie der Nutzer sie genannt hat, also zählen beide.
      */
     async mcpServersAm(ort) {
+        const heim = zusaetzlichesHeim(ort);
+        if (heim !== undefined)
+            throw new HeimOhneCliZugriff(this.harness.name, heim, 'MCP-Server');
         const daten = await this.claudeJsonLesen();
         if (ort.art === 'home')
             return mcpServersVon(daten);
@@ -355,7 +377,7 @@ class ClaudeMcp {
     }
     async claudeJsonLesen() {
         try {
-            const text = await readFile(path.join(this.home, '.claude.json'), 'utf8');
+            const text = await readFile(path.join(this.home(), '.claude.json'), 'utf8');
             return JSON.parse(ohneBom(text));
         }
         catch {
@@ -365,29 +387,42 @@ class ClaudeMcp {
 }
 export class ClaudeCode {
     name = 'claude-code';
-    home;
+    heime;
     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. */
     plugins;
     /** Wird von `vorhanden()` gesetzt, sobald die claude-CLI auf dem PATH liegt (E61). */
     mcp;
     geprueft = false;
-    constructor(home, ausfuehrer = claudeAusfuehrer) {
-        this.home = home;
+    /**
+     * `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.
+     */
+    constructor(heime, ausfuehrer = claudeAusfuehrer, zugriffFuer) {
+        this.heime = typeof heime === 'string' ? nurHome(heime) : heime;
         this.ausfuehrer = ausfuehrer;
+        const lokal = new LokalerZugriff();
+        this.zugriffFuer = zugriffFuer ?? (() => lokal);
     }
     /**
-     * Claude Code liegt auf dem Rechner, wenn es sein Home angelegt hat. Die Plugin- und
+     * 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.
      */
     async vorhanden() {
-        const da = (await stat(path.join(this.home, '.claude')).catch(() => undefined)) !== undefined;
+        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.home);
+                this.mcp = new ClaudeMcp(this, this.ausfuehrer, () => this.heime.primaer(this.name));
             }
         }
         return da;
@@ -395,15 +430,21 @@ export class ClaudeCode {
     orte() {
         return ['home', 'arbeitsverzeichnis'];
     }
+    /** Fähigkeit: zusätzliche Homedirs (E78, F87). Das Layout ist ein fester Ordner, kein Konfigeintrag. */
+    zusaetzlicheHeime() {
+        return true;
+    }
     zielVerzeichnis(ort) {
         if (ort.art === 'home')
-            return path.join(this.home, '.claude', 'skills');
+            return heimVerbinden(ort, this.heime.pfad(this.name, ort), CLAUDE_VERZEICHNIS, SKILLS_ORDNER);
         if (ort.art === 'arbeitsverzeichnis')
-            return path.join(ort.pfad, '.claude', 'skills');
+            return path.join(ort.pfad, CLAUDE_VERZEICHNIS, SKILLS_ORDNER);
         throw new OrtNichtUnterstuetzt(this.name, ort.art);
     }
     async vorbereiten(ort) {
-        await mkdir(this.zielVerzeichnis(ort), { recursive: true });
+        // Ü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));
         if (ort.art === 'arbeitsverzeichnis' && (await istGitRepo(ort.pfad)))
             await gitignoreEintragen(ort.pfad, GITIGNORE_ZEILE);
     }

package/dist/adapter/dateisystem.js

@@ -45,15 +45,63 @@ export function linkFehlerHinweis(plattform = process.platform) {
         ? 'Aktiviere den Windows-Entwicklermodus (Einstellungen → System → Für Entwickler) oder starte hmgr mit Administratorrechten.'
         : 'Prüfe die Schreibrechte auf das Zielverzeichnis und ob das Linkziel vorhanden ist.';
 }
+/**
+ * Zugriff auf das lokale Dateisystem (E78): der Weg, den hmgr immer schon ging, jetzt hinter dem
+ * Port. Linkziele brauchen keine Übersetzung, sie stehen schon in der Schreibweise des Rechners.
+ */
+export class LokalerZugriff {
+    trenner = path.sep;
+    verbinden(verzeichnis, name) {
+        return path.join(verzeichnis, name);
+    }
+    async namen(verzeichnis) {
+        return await readdir(verzeichnis).catch(() => []);
+    }
+    async info(pfad) {
+        const roh = await lstat(pfad).catch(() => undefined);
+        if (roh === undefined)
+            return undefined;
+        if (!roh.isSymbolicLink())
+            return { istLink: false, istVerzeichnis: roh.isDirectory() };
+        return { istLink: true, istVerzeichnis: (await stat(pfad).catch(() => undefined))?.isDirectory() === true };
+    }
+    async linkZiel(pfad) {
+        const info = await lstat(pfad).catch(() => undefined);
+        if (!info || !info.isSymbolicLink())
+            return undefined;
+        // Junctions meldet Node als Symlink, ihr Ziel aber mit `\\?\`-Präfix (E66): erst kürzen, dann
+        // auflösen, sonst ergäbe `path.resolve` einen Pfad, der zu keinem Soll-Ziel passt.
+        return path.resolve(path.dirname(pfad), ohneWindowsPraefix(await readlink(pfad)));
+    }
+    async verzeichnisAnlegen(pfad) {
+        await mkdir(pfad, { recursive: true });
+    }
+    async linkAnlegen(pfad, hostZiel) {
+        await symlink(hostZiel, pfad, symlinkTyp());
+    }
+    async linkEntfernen(pfad) {
+        await unlink(pfad);
+    }
+    async loeschen(pfad) {
+        await rm(pfad, { recursive: true, force: true });
+    }
+}
 export class DateisystemZiele {
     wurzel;
     zustand;
     /** $XDG_STATE_HOME, falls gesetzt und nicht leer, für den vorrangigen Lockfile-Ort (E50). */
     xdgStateHome;
-    constructor(wurzel, zustand, xdgStateHome) {
+    /**
+     * Welcher Zugriff zu welchem Ziel gehört (E78): lokal wie bisher, für ein WSL-Heim die Bridge.
+     * Ohne Angabe ist alles lokal — so bleibt der Adapter ohne Windows-Umgebung derselbe wie vorher.
+     */
+    zugriffFuer;
+    lokal = new LokalerZugriff();
+    constructor(wurzel, zustand, xdgStateHome, zugriffFuer) {
         this.wurzel = wurzel;
         this.zustand = zustand;
         this.xdgStateHome = xdgStateHome;
+        this.zugriffFuer = zugriffFuer ?? (() => this.lokal);
     }
     async quellen() {
         return (await this.zustand.lesen()).quellen;
@@ -105,37 +153,22 @@ export class DateisystemZiele {
         }
         return undefined;
     }
-    async linkZiel(verzeichnis, name) {
-        const pfad = path.join(verzeichnis, name);
-        const info = await lstat(pfad).catch(() => undefined);
-        if (!info || !info.isSymbolicLink())
-            return undefined;
-        // Junctions meldet Node als Symlink, ihr Ziel aber mit `\\?\`-Präfix (E66): erst kürzen, dann
-        // auflösen, sonst ergäbe `path.resolve` einen Pfad, der zu keinem Soll-Ziel passt.
-        return path.resolve(verzeichnis, ohneWindowsPraefix(await readlink(pfad)));
-    }
     /**
      * Ein Skill ist ein Verzeichnis. Dateien wie .DS_Store zählen nicht als fremder Eintrag,
-     * ebenso wenig ein Symlink, der auf keine Verzeichnis zeigt.
+     * ebenso wenig ein Symlink, der auf kein Verzeichnis zeigt.
      */
-    async istVerzeichnis(verzeichnis, name) {
-        const pfad = path.join(verzeichnis, name);
-        const info = await lstat(pfad).catch(() => undefined);
-        if (info === undefined)
-            return false;
-        if (info.isDirectory())
-            return true;
-        if (!info.isSymbolicLink())
-            return false;
-        return (await stat(pfad).catch(() => undefined))?.isDirectory() === true;
+    istVerzeichnis(info) {
+        return info !== undefined && info.istVerzeichnis;
     }
     async eintraege(ziel, verzeichnis) {
-        const namen = await readdir(verzeichnis).catch(() => []);
+        const zugriff = this.zugriffFuer(ziel);
+        const namen = await zugriff.namen(verzeichnis);
         const ergebnis = [];
-        for (const name of namen.sort()) {
-            if (!(await this.istVerzeichnis(verzeichnis, name)))
+        for (const name of [...namen].sort()) {
+            const pfad = zugriff.verbinden(verzeichnis, name);
+            if (!this.istVerzeichnis(await zugriff.info(pfad)))
                 continue;
-            const zielPfad = await this.linkZiel(verzeichnis, name);
+            const zielPfad = await zugriff.linkZiel(pfad);
             const gedeutet = zielPfad ? await this.deuten(zielPfad) : undefined;
             if (gedeutet?.art === 'link')
                 ergebnis.push({ art: 'link', link: { ziel, name, checkout: gedeutet.checkout, skill: gedeutet.skill } });
@@ -148,20 +181,21 @@ export class DateisystemZiele {
         return ergebnis;
     }
     async linkLegen(ziel, verzeichnis, name, checkout, skill, ersetzen) {
+        const zugriff = this.zugriffFuer(ziel);
         // Ein leerer Name oder einer mit Pfadtrenner ergäbe keinen Eintrag im Ziel, sondern einen Pfad:
-        // `path.join` fiele auf das Zielverzeichnis selbst zurück, und `ersetzen` löschte es (E12, E32).
-        if (name.length === 0 || name.includes('/') || name.includes(path.sep))
+        // `verbinden` fiele auf das Zielverzeichnis selbst zurück, und `ersetzen` löschte es (E12, E32).
+        if (name.length === 0 || name.includes('/') || name.includes(zugriff.trenner))
             throw new Error(`Ungültiger Name für einen Link: „${name}"`);
-        await mkdir(verzeichnis, { recursive: true });
-        const pfad = path.join(verzeichnis, name);
-        const info = await lstat(pfad).catch(() => undefined);
+        await zugriff.verzeichnisAnlegen(verzeichnis);
+        const pfad = zugriff.verbinden(verzeichnis, name);
+        const info = await zugriff.info(pfad);
         if (info) {
-            const zielPfad = await this.linkZiel(verzeichnis, name);
+            const zielPfad = await zugriff.linkZiel(pfad);
             const eigen = zielPfad ? await this.deuten(zielPfad) : undefined;
             if (eigen)
-                await unlink(pfad);
+                await zugriff.linkEntfernen(pfad);
             else if (ersetzen)
-                await rm(pfad, { recursive: true, force: true });
+                await zugriff.loeschen(pfad);
             else
                 throw new NameBelegt(ziel, name);
         }
@@ -171,33 +205,36 @@ export class DateisystemZiele {
         // relativer Pfad. `path.resolve` kostet nichts und macht die Zusage hier fest.
         const checkoutZiel = path.resolve(checkout.pfad, skill.pfad);
         try {
-            await symlink(checkoutZiel, pfad, symlinkTyp());
+            await zugriff.linkAnlegen(pfad, checkoutZiel);
         }
         catch (ursache) {
             throw new LinkAnlegenFehlgeschlagen(pfad, checkoutZiel, ursache instanceof Error ? ursache.message : String(ursache), linkFehlerHinweis());
         }
     }
-    async linkEntfernen(_ziel, verzeichnis, name) {
-        const zielPfad = await this.linkZiel(verzeichnis, name);
+    async linkEntfernen(ziel, verzeichnis, name) {
+        const zugriff = this.zugriffFuer(ziel);
+        const pfad = zugriff.verbinden(verzeichnis, name);
+        const zielPfad = await zugriff.linkZiel(pfad);
         if (!zielPfad)
             return;
         if (await this.deuten(zielPfad))
-            await unlink(path.join(verzeichnis, name));
+            await zugriff.linkEntfernen(pfad);
     }
     /**
      * Löscht einen fremden Eintrag von der Platte (E46): ein Symlink wird als Link entfernt, ohne
      * ihm zu folgen, die Arbeitskopie dahinter bleibt unangetastet; ein Verzeichnis wird rekursiv
      * gelöscht. Ob der Eintrag tatsächlich fremd ist, hat der Kern schon geprüft.
      */
-    async eintragLoeschen(_ziel, verzeichnis, name) {
-        const pfad = path.join(verzeichnis, name);
-        const info = await lstat(pfad).catch(() => undefined);
+    async eintragLoeschen(ziel, verzeichnis, name) {
+        const zugriff = this.zugriffFuer(ziel);
+        const pfad = zugriff.verbinden(verzeichnis, name);
+        const info = await zugriff.info(pfad);
         if (info === undefined)
             return;
-        if (info.isSymbolicLink())
-            await unlink(pfad);
+        if (info.istLink)
+            await zugriff.linkEntfernen(pfad);
         else
-            await rm(pfad, { recursive: true, force: true });
+            await zugriff.loeschen(pfad);
     }
     /**
      * Lockfile-Kandidaten in Suchreihenfolge (E50): zuerst $XDG_STATE_HOME/skills/.skill-lock.json,
@@ -235,6 +272,11 @@ export class DateisystemZiele {
         }
     }
     /**
+     * Lockfile und Ordner-Hash lesen immer lokal, nie über die Bridge (E78): beide gehören zur
+     * Übernahme-Erkennung eines agents-Ziels (E48 b), und zusätzliche Homedirs gibt es bisher nur bei
+     * claude-code. Käme das je zusammen, wäre der Ordner-Hash über die Bridge außerdem ein Lesen
+     * jeder Datei einzeln — dann lieber ein eigener Schnitt als ein stiller Sonderweg hier.
+     *
      * Lockfile der skills-CLI (E48 b, E50, HARNESS-FAKTEN). Fehlt die Datei am ersten Kandidaten,
      * wird der nächste versucht; ist sie da, aber kein gültiges JSON oder trägt der Eintrag nicht die
      * nötigen Felder, gibt es undefined zurück statt zu werfen: ein kaputtes Lockfile bricht die

package/dist/adapter/heime.js

@@ -0,0 +1,76 @@
+// Homedirs eines Harness aus dem Zustand (E78). Synchron, siehe HeimePort.
+import path from 'node:path';
+import { HeimUnbekannt, OrtNichtUnterstuetzt, heimAdresseZerlegen } 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
+ * Ziel, das nur Linux zu Gesicht bekommt.
+ */
+export function heimVerbinden(ort, ...teile) {
+    const adresse = ort.art === 'home' ? ort.heim : undefined;
+    return adresse !== undefined && heimAdresseZerlegen(adresse) !== undefined
+        ? path.posix.join(...teile)
+        : path.join(...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
+ * Ziel anderswo nicht angezeigt und nicht bedient.
+ */
+export function heimBedienbar(adresse, plattform) {
+    const zerlegt = heimAdresseZerlegen(adresse);
+    if (zerlegt === undefined)
+        return false;
+    return plattform === 'win32';
+}
+export class ZustandHeime {
+    zustand;
+    home;
+    plattform;
+    /** `home` ist das HOME des Nutzers: das primäre Homedir, solange nichts anderes eingetragen ist. */
+    constructor(zustand, home, plattform = process.platform) {
+        this.zustand = zustand;
+        this.home = home;
+        this.plattform = plattform;
+    }
+    eintrag(harness) {
+        return this.zustand.lesenSync().harnessHeime.find((h) => h.harness === harness);
+    }
+    primaer(harness) {
+        const pfad = this.eintrag(harness)?.pfad;
+        return pfad !== undefined && pfad.length > 0 ? pfad : this.home;
+    }
+    zusaetzliche(harness) {
+        return (this.eintrag(harness)?.zusaetzliche ?? [])
+            .filter((h) => heimBedienbar(h.adresse, this.plattform))
+            .map((h) => ({ adresse: h.adresse, pfad: h.pfad }));
+    }
+    alle(harness) {
+        return [{ pfad: this.primaer(harness) }, ...this.zusaetzliche(harness)];
+    }
+    pfad(harness, ort) {
+        if (ort.art !== 'home')
+            throw new OrtNichtUnterstuetzt(harness, ort.art);
+        if (ort.heim === undefined)
+            return this.primaer(harness);
+        const treffer = this.zusaetzliche(harness).find((h) => h.adresse === ort.heim);
+        if (treffer === undefined)
+            throw new HeimUnbekannt(harness, ort.heim);
+        return treffer.pfad;
+    }
+}
+/** Der Standardfall ohne Zustand: ein Harness hat genau ein Homedir, das Home des Nutzers. */
+export function nurHome(home) {
+    return {
+        primaer: () => home,
+        zusaetzliche: () => [],
+        alle: () => [{ pfad: home }],
+        pfad: (harness, ort) => {
+            if (ort.art !== 'home')
+                throw new OrtNichtUnterstuetzt(harness, ort.art);
+            if (ort.heim !== undefined)
+                throw new HeimUnbekannt(harness, ort.heim);
+            return home;
+        },
+    };
+}

package/dist/adapter/hermes.js

@@ -6,6 +6,7 @@ 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 { tiefGleich } from "./vergleich.js";
 const HERMES_VERZEICHNIS = '.hermes';
 const PROFILE_VERZEICHNIS = 'profiles';
@@ -68,7 +69,7 @@ function mcpKonfigAlsObjekt(konfig) {
 }
 export class Hermes {
     name = 'hermes';
-    home;
+    heime;
     /**
      * 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.
@@ -80,9 +81,16 @@ export class Hermes {
         eingehaengte: async (ort) => this.mcpEingehaengte(ort),
         envDatei: (ort) => path.join(this.mcpHermesHome(ort), '.env'),
     };
-    /** `home` ist das HOME des Nutzers, das Hermes-Home liegt darunter als `.hermes`. */
-    constructor(home) {
-        this.home = home;
+    /**
+     * `heime` sagt, wo das Homedir liegt (E78, F89): umstellbar, aber ohne zusätzliche Homedirs.
+     * 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) {
+        this.heime = typeof heime === 'string' ? nurHome(heime) : heime;
+    }
+    get home() {
+        return this.heime.primaer(this.name);
     }
     /** Hermes liegt auf dem Rechner, wenn es sein Home angelegt hat. */
     async vorhanden() {
@@ -93,11 +101,12 @@ export class Hermes {
     }
     /** Home und Profil sind dasselbe Konzept: ein vollständiges Hermes-Home (E13). */
     hermesHome(ort) {
-        const basis = path.join(this.home, HERMES_VERZEICHNIS);
+        // Über `heime.pfad` statt über `this.home`: nennt der Ort ein zusätzliches Homedir, wirft der
+        // Port (E78). Hermes hat die Fähigkeit nicht, ein solcher Ort dürfte hier gar nicht ankommen.
         if (ort.art === 'home')
-            return basis;
+            return path.join(this.heime.pfad(this.name, ort), HERMES_VERZEICHNIS);
         if (ort.art === 'profil')
-            return path.join(basis, PROFILE_VERZEICHNIS, ort.name);
+            return path.join(this.home, HERMES_VERZEICHNIS, PROFILE_VERZEICHNIS, ort.name);
         throw new OrtNichtUnterstuetzt(this.name, ort.art);
     }
     /** Tilde gegen HOME, relative Pfade gegen das Hermes-Home. Variablen löst hmgr nicht auf. */

package/dist/adapter/npm-registry.js

@@ -0,0 +1,68 @@
+// Die auf npm veröffentlichte Version der hmgr-CLI (E77). npm ist der Kanal der CLI (F83=O1), der
+// Gitea-Feed (E73) gehört allein der GUI — deshalb fragt dieser Adapter die npm-Registry und nennt
+// in der Meldung genau den Befehl, der über npm installiert.
+//
+// Jeder Fehlschlag ist still: offline, DNS weg, Registry langsam, unerwartetes JSON. Ein
+// Update-Hinweis ist eine Beigabe, nie ein Grund, einen Lauf scheitern zu lassen oder den Nutzer
+// mit einer Netzwerkmeldung zu behelligen. Wer mitlesen will, gibt `protokoll` mit.
+import { versionIstNeuer } from "../kern/version.js";
+/** Der Befehl, den die Meldung verspricht — und das einzige, was sie verspricht: hmgr installiert nie selbst. */
+export const NPM_BEFEHL = 'npm install -g hmgr@latest';
+/** Kurzer Timeout: die Prüfung hängt an einem Knopfdruck, sie darf ihn nicht spürbar aufhalten. */
+const TIMEOUT_MS = 4000;
+/**
+ * Die aktuelle Version eines Pakets laut npm-Registry, oder null. `/<paket>/latest` liefert das
+ * Manifest der Dist-Tag-Version `latest`, daraus zählt nur das Feld `version`.
+ */
+export async function npmVersion(paket, optionen = {}) {
+    const protokoll = optionen.protokoll ?? (() => undefined);
+    const abbruch = new AbortController();
+    const wecker = setTimeout(() => abbruch.abort(), optionen.timeoutMs ?? TIMEOUT_MS);
+    try {
+        const antwort = await fetch(`https://registry.npmjs.org/${paket}/latest`, {
+            signal: abbruch.signal,
+            headers: { accept: 'application/json' },
+        });
+        if (!antwort.ok) {
+            protokoll(`[npm] ${paket}: HTTP ${antwort.status}`);
+            return null;
+        }
+        const daten = (await antwort.json());
+        if (typeof daten.version !== 'string') {
+            protokoll(`[npm] ${paket}: Antwort ohne Versionsfeld`);
+            return null;
+        }
+        return daten.version;
+    }
+    catch (fehler) {
+        protokoll(`[npm] ${paket}: ${fehler instanceof Error ? fehler.message : String(fehler)}`);
+        return null;
+    }
+    finally {
+        clearTimeout(wecker);
+    }
+}
+/**
+ * Die eine Zeile, die GUI-Sidebar und `hmgr update` gleichlautend zeigen. `installiert === null`
+ * heißt: eine hmgr-CLI ist da, aber so alt (vor 0.0.7, E72), dass sie ihre Version nicht sagen
+ * kann — dieser Fall meldet sich auch ohne `neu` (Registry unerreichbar), denn die Warnung „veraltet"
+ * hängt nicht am Netz, nur der Vergleich mit npm tut das.
+ */
+export function cliHinweisText(installiert, neu) {
+    if (installiert !== null && neu !== null)
+        return `hmgr-CLI ${installiert} — npm hat ${neu}: ${NPM_BEFEHL}`;
+    if (neu !== null)
+        return `hmgr-CLI veraltet (vor 0.0.7, kennt --version nicht) — npm hat ${neu}: ${NPM_BEFEHL}`;
+    return `hmgr-CLI veraltet (vor 0.0.7, kennt --version nicht): ${NPM_BEFEHL}`;
+}
+export async function cliUpdateHinweis(installiert, optionen = {}) {
+    const neu = await npmVersion('hmgr', optionen);
+    if (installiert === null) {
+        // `text` für die CLI (eine Zeile), die Einzelteile für die GUI, die den Befehl hervorhebt. Der
+        // Befehl kommt mit, damit er nicht ein zweites Mal im Renderer steht.
+        return { installiert: null, neu, befehl: NPM_BEFEHL, text: cliHinweisText(null, neu) };
+    }
+    if (neu === null || !versionIstNeuer(neu, installiert))
+        return null;
+    return { installiert, neu, befehl: NPM_BEFEHL, text: cliHinweisText(installiert, neu) };
+}

package/dist/adapter/umgebung.js

@@ -2,8 +2,13 @@
 import { readFile } from 'node:fs/promises';
 export class ProzessUmgebung {
     env;
-    constructor(env = process.env) {
+    plattformName;
+    constructor(env = process.env, plattform = process.platform) {
         this.env = env;
+        this.plattformName = plattform;
+    }
+    plattform() {
+        return this.plattformName;
     }
     variablen() {
         const ergebnis = {};

package/dist/adapter/verlauf-json.js

@@ -0,0 +1,39 @@
+// Der Verlauf als eine JSON-Datei, Standard ~/.hmgr/verlauf.json (E80). Analog ZustandJson
+// (zustand-json.ts), aber ohne Fassungs-Migration: das Format ist neu, `fassung: 1` reicht.
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+import { leererVerlauf } from "../ports/verlauf.js";
+import { ohneBom } from "./datei-text.js";
+/** Höchstzahl der Einträge in der Datei (E80): ein Changelog, keine Historie ohne Ende. */
+const MAX_EINTRAEGE = 20;
+/** Der gelesene Text als Verlauf. Fehlt ein Feld oder ist die Form falsch, gilt der leere Verlauf. */
+function deuten(roh) {
+    const daten = JSON.parse(ohneBom(roh));
+    const gemerkt = typeof daten.gemerkt === 'object' && daten.gemerkt !== null ? daten.gemerkt : {};
+    const eintraege = Array.isArray(daten.eintraege) ? daten.eintraege : [];
+    return { gemerkt, eintraege };
+}
+export class VerlaufJson {
+    pfad;
+    constructor(hmgrHome) {
+        this.pfad = path.join(hmgrHome, 'verlauf.json');
+    }
+    async lesen() {
+        const roh = await readFile(this.pfad, 'utf8').catch(() => undefined);
+        if (roh === undefined)
+            return leererVerlauf();
+        try {
+            return deuten(roh);
+        }
+        catch {
+            // Kaputtes JSON (analog ZustandJson, deuten) darf den Lauf nicht abbrechen: leerer Verlauf.
+            return leererVerlauf();
+        }
+    }
+    async schreiben(daten) {
+        await mkdir(path.dirname(this.pfad), { recursive: true });
+        // Neueste zuerst kappen, nicht sortieren: die Reihenfolge liegt beim Aufrufer.
+        const gekappt = { gemerkt: daten.gemerkt, eintraege: daten.eintraege.slice(0, MAX_EINTRAEGE) };
+        await writeFile(this.pfad, `${JSON.stringify({ fassung: 1, ...gekappt }, null, 2)}\n`);
+    }
+}