hmgr 0.0.6 → 0.0.12

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,61 @@
+// 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. */
+export function cliHinweisText(installiert, neu) {
+    return `hmgr-CLI ${installiert} — npm hat ${neu}: ${NPM_BEFEHL}`;
+}
+/**
+ * Fragt die Registry und gibt die fertige Meldung zurück — oder null, wenn nichts zu melden ist:
+ * Registry unerreichbar, gleiche Version, oder die installierte ist die neuere (ein Selbstbau aus
+ * dem Clone liegt regelmäßig vor npm).
+ */
+export async function cliUpdateHinweis(installiert, optionen = {}) {
+    const neu = await npmVersion('hmgr', optionen);
+    if (neu === null || !versionIstNeuer(neu, installiert))
+        return 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, neu, befehl: NPM_BEFEHL, text: cliHinweisText(installiert, neu) };
+}

package/dist/adapter/paket-version.js

@@ -0,0 +1,25 @@
+// Die Version des Pakets, gelesen aus seiner package.json (E72). Keine Kopie im Code: eine
+// zweite Stelle mit derselben Zahl geht früher oder später auseinander.
+import { readFileSync } from 'node:fs';
+/**
+ * Die package.json liegt in jeder Lage zwei Ebenen über diesem Modul: in der Quelle
+ * `src/adapter/` → Wurzel, im Build `dist/adapter/` → Wurzel, in der npm-Installation
+ * `node_modules/hmgr/dist/adapter/` → `node_modules/hmgr/`, im gepackten App-Bundle
+ * `app.asar/dist/adapter/` → `app.asar/`. Aufgelöst über `import.meta.url`, damit weder das
+ * Arbeitsverzeichnis noch der Aufrufweg hineinspielt.
+ *
+ * Bewusst kein Import mit `with { type: 'json' }`: der zöge die package.json beim Bauen nach
+ * `dist` und legte damit eine zweite Wahrheit an.
+ */
+const PAKET_JSON = new URL('../../package.json', import.meta.url);
+let gemerkt;
+/** Die Versionsnummer aus der package.json des Pakets, etwa „0.0.6". */
+export function paketVersion() {
+    if (gemerkt === undefined) {
+        const inhalt = JSON.parse(readFileSync(PAKET_JSON, 'utf8'));
+        if (typeof inhalt.version !== 'string')
+            throw new Error(`Die package.json unter ${PAKET_JSON.pathname} nennt keine Version.`);
+        gemerkt = inhalt.version;
+    }
+    return gemerkt;
+}

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`);
+    }
+}

package/dist/adapter/wsl.js

@@ -0,0 +1,212 @@
+// Die Bridge in eine WSL-Distro (E78): `wsl.exe -d <distro> <linux-kommando>`. Über `\\wsl$` geht
+// nichts davon — Windows legt dort keine Links an und liest durch Linux-Symlinks nicht hindurch
+// (gemessen, HARNESS-FAKTEN „Links zwischen Windows und WSL").
+import spawn from 'cross-spawn';
+import path from 'node:path';
+import { WslBrueckeFehlgeschlagen } from "../kern/modell.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 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'], timeout: 60_000, killSignal: 'SIGKILL' });
+    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 }));
+});
+/**
+ * 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
+ * ungerades Byte am Ende (abgeschnittene Ausgabe) fällt weg statt ein Ersatzzeichen zu ergeben.
+ */
+export function utf16Text(ausgabe) {
+    const gerade = ausgabe.length % 2 === 0 ? ausgabe : ausgabe.subarray(0, ausgabe.length - 1);
+    return gerade.toString('utf16le').replace(/^\uFEFF/, '');
+}
+/**
+ * Die Distronamen aus `wsl -l -q` (E78): eine je Zeile, UTF-16LE. Leerzeilen und Reste des
+ * Zeilenumbruchs fallen weg. Der Standard-Distro hängt in anderen Listenformen ein „(Standard)" an,
+ * `-q` liefert nur die nackten Namen.
+ */
+export function distroListeLesen(ausgabe) {
+    return utf16Text(ausgabe)
+        .split(/\r?\n/)
+        .map((zeile) => zeile.trim())
+        .filter((zeile) => zeile.length > 0);
+}
+/**
+ * Ein Wert für die einfach zitierte Form der Shell: alles bleibt wörtlich, ein enthaltenes
+ * Apostroph wird ausgeklammert. Ohne das zerfiele ein Pfad mit Leerzeichen in mehrere Argumente,
+ * sobald wsl.exe die Kommandozeile wieder zusammensetzt.
+ */
+export function shZitat(text) {
+    return `'${text.replace(/'/g, `'\\''`)}'`;
+}
+/**
+ * Ein POSIX-Pfad in die Windows-Schreibweise (E78): `/mnt/c/work/quelle` wird `C:\work\quelle`.
+ * `wurzel` ist die Automount-Wurzel der Distro, üblich `/mnt`, aber über `[automount] root`
+ * einstellbar — deshalb wird sie einmal per `wslpath` ermittelt statt geraten. Ein Pfad außerhalb
+ * (im Linux-Dateisystem) hat keine Windows-Entsprechung: `undefined`.
+ */
+export function wslNachWindows(pfad, wurzel) {
+    const basis = wurzel.endsWith('/') ? wurzel.slice(0, -1) : wurzel;
+    const treffer = new RegExp(`^${basis.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}/([a-zA-Z])(/.*)?$`).exec(pfad);
+    if (treffer === null)
+        return undefined;
+    const rest = (treffer[2] ?? '').replace(/\//g, '\\');
+    return `${treffer[1].toUpperCase()}:${rest.length === 0 ? '\\' : rest}`;
+}
+/**
+ * Die Gegenrichtung: `C:\work\quelle` wird `/mnt/c/work/quelle`. Ein Pfad ohne Laufwerksbuchstaben
+ * (UNC, relativ) hat keine Entsprechung unter der Automount-Wurzel: `undefined`.
+ */
+export function windowsNachWsl(pfad, wurzel) {
+    const treffer = /^([a-zA-Z]):[\\/](.*)$/.exec(pfad);
+    if (treffer === null)
+        return undefined;
+    const basis = wurzel.endsWith('/') ? wurzel.slice(0, -1) : wurzel;
+    const rest = treffer[2].replace(/\\/g, '/').replace(/\/+$/, '');
+    return `${basis}/${treffer[1].toLowerCase()}${rest.length === 0 ? '' : `/${rest}`}`;
+}
+/**
+ * Eine WSL-Distro über die Bridge. Jede Dateisystem-Operation läuft als `/bin/sh -c "<skript>"` in
+ * der Distro; Pfade gehen einfach zitiert hinein (`shZitat`), weil wsl.exe die Kommandozeile wieder
+ * zusammensetzt und ein Leerzeichen sonst trennte.
+ */
+export class WslBruecke {
+    distro;
+    ausfuehren;
+    /** Automount-Wurzel, einmal je Lauf ermittelt: ein `wslpath`-Aufruf statt einem je Linkziel. */
+    wurzelVersprechen;
+    constructor(distro, ausfuehren = wslAusfuehrer) {
+        this.distro = distro;
+        this.ausfuehren = ausfuehren;
+    }
+    /** Ein Linux-Kommando in der Distro, Ausgabe als UTF-8. Wirft, wenn die Bridge selbst scheitert. */
+    async sh(skript) {
+        const { ausgabe, code } = await this.ausfuehren(['-d', this.distro, '/bin/sh', '-c', skript]);
+        const text = ausgabe.toString('utf8');
+        if (code !== 0)
+            throw new WslBrueckeFehlgeschlagen(this.distro, text);
+        return text;
+    }
+    /** 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]);
+        return code === 0 ? ausgabe.toString('utf8') : undefined;
+    }
+    /**
+     * Das Home des Standardbenutzers der Distro (F87). wsl.exe startet als dieser Benutzer — derselbe,
+     * der Claude Code dort interaktiv nutzt; eine Benutzer-Option gibt es deshalb nicht.
+     */
+    async home() {
+        const text = (await this.sh('echo $HOME')).trim();
+        if (text.length === 0)
+            throw new WslBrueckeFehlgeschlagen(this.distro, 'kein $HOME in der Distro');
+        return text;
+    }
+    /**
+     * Die Automount-Wurzel, aus `wslpath -u 'C:\'`. wslpath kommt von WSL selbst und liegt auch in
+     * einer Minimal-Distro (gemessen). Schlägt der Aufruf fehl, gilt der Standard `/mnt`: eine
+     * Übersetzung mit der üblichen Wurzel ist besser als gar keine.
+     */
+    async wurzel() {
+        this.wurzelVersprechen ??= (async () => {
+            const text = await this.shWeich(`wslpath -u ${shZitat('C:\\')}`);
+            const pfad = text?.trim() ?? '';
+            const treffer = /^(.*)\/[a-zA-Z]\/?$/.exec(pfad);
+            return treffer?.[1] !== undefined && treffer[1].length > 0 ? treffer[1] : '/mnt';
+        })();
+        return this.wurzelVersprechen;
+    }
+    /** Einen Pfad der Distro in die Schreibweise des Windows-Rechners. Ohne Entsprechung: unverändert. */
+    async nachHost(pfad) {
+        return wslNachWindows(pfad, await this.wurzel()) ?? pfad;
+    }
+    /** Die Gegenrichtung. Ohne Entsprechung: unverändert — der Link zeigt dann eben ins Leere. */
+    async vomHost(pfad) {
+        return windowsNachWsl(pfad, await this.wurzel()) ?? pfad;
+    }
+}
+/** Die installierten Distros (`wsl -l -q`). Ohne wsl.exe oder ohne Distro: leere Liste. */
+export async function wslDistros(ausfuehren = wslAusfuehrer) {
+    const { ausgabe, code } = await ausfuehren(['-l', '-q']);
+    if (code !== 0)
+        return [];
+    return distroListeLesen(ausgabe);
+}
+/**
+ * Zugriff auf ein Zielverzeichnis in einer WSL-Distro (E78). Jede Operation ist ein Aufruf über die
+ * Bridge; Pfade sind POSIX-Pfade der Distro, Linkziele übersetzt der Zugriff selbst nach `/mnt/c`
+ * und zurück. Ein Symlink im WSL-Home darf auf `/mnt/c/…` zeigen — die Distro liest selbst
+ * hindurch, also bleiben die vorhandenen Windows-Checkouts die Linkziele (gemessen).
+ */
+export class WslZugriff {
+    trenner = '/';
+    bruecke;
+    constructor(bruecke) {
+        this.bruecke = bruecke;
+    }
+    verbinden(verzeichnis, name) {
+        return path.posix.join(verzeichnis, name);
+    }
+    /**
+     * `ls -1A` statt `find -printf`: letzteres ist eine GNU-Erweiterung und fehlt in einer
+     * Busybox-Distro. Ein Name mit Zeilenumbruch zerfiele dabei — bei Skill-Ordnern kommt das nicht
+     * vor, und der Preis wäre ein Sonderformat für einen Fall, den es nicht gibt.
+     */
+    async namen(verzeichnis) {
+        const text = await this.weich(`ls -1A ${shZitat(verzeichnis)} 2>/dev/null`);
+        if (text === undefined)
+            return [];
+        return text
+            .split('\n')
+            .map((zeile) => zeile.replace(/\r$/, ''))
+            .filter((zeile) => zeile.length > 0);
+    }
+    /**
+     * Drei Ja/Nein-Fragen in einem Aufruf: gibt es den Eintrag (auch als toten Link), ist er ein Link,
+     * zeigt er auf ein Verzeichnis. `-d` folgt dem Link, `-L` nicht — genau die Aufteilung, die der
+     * lokale Zugriff mit lstat und stat trifft.
+     */
+    async info(pfad) {
+        const p = shZitat(pfad);
+        const text = await this.weich(`if [ -e ${p} ] || [ -L ${p} ]; then printf e; fi; if [ -L ${p} ]; then printf l; fi; if [ -d ${p} ]; then printf d; fi`);
+        if (text === undefined || !text.includes('e'))
+            return undefined;
+        return { istLink: text.includes('l'), istVerzeichnis: text.includes('d') };
+    }
+    async linkZiel(pfad) {
+        const text = await this.weich(`readlink ${shZitat(pfad)}`);
+        if (text === undefined)
+            return undefined;
+        const ziel = text.trim();
+        if (ziel.length === 0)
+            return undefined;
+        // Ein relatives Linkziel gibt es bei hmgr-Links nicht, aber ein von Hand gelegter Link könnte
+        // eines haben: erst gegen das Verzeichnis auflösen, dann übersetzen.
+        const absolut = ziel.startsWith('/') ? ziel : path.posix.resolve(path.posix.dirname(pfad), ziel);
+        return await this.bruecke.nachHost(absolut);
+    }
+    async verzeichnisAnlegen(pfad) {
+        await this.bruecke.sh(`mkdir -p ${shZitat(pfad)}`);
+    }
+    async linkAnlegen(pfad, hostZiel) {
+        const ziel = await this.bruecke.vomHost(hostZiel);
+        await this.bruecke.sh(`ln -sfn ${shZitat(ziel)} ${shZitat(pfad)}`);
+    }
+    async linkEntfernen(pfad) {
+        await this.bruecke.sh(`rm -f ${shZitat(pfad)}`);
+    }
+    async loeschen(pfad) {
+        await this.bruecke.sh(`rm -rf ${shZitat(pfad)}`);
+    }
+    /** Lesende Abfragen brechen nicht ab, wenn die Distro schweigt: sie ergeben dann „nichts da". */
+    async weich(skript) {
+        return await this.bruecke.sh(skript).catch(() => undefined);
+    }
+}

package/dist/adapter/zustand-json.js

@@ -1,8 +1,29 @@
 // Lokaler Zustand als eine JSON-Datei, Standard ~/.hmgr/state.json (E29).
+import { readFileSync } from 'node:fs';
 import { mkdir, readFile, writeFile } from 'node:fs/promises';
 import path from 'node:path';
-import { leererZustand } from "../ports/zustand.js";
+import { ZUSTAND_FASSUNG, leererZustand, } from "../ports/zustand.js";
 import { ohneBom } from "./datei-text.js";
+/** Der gelesene Text als Zustand. Fehlende Felder bekommen den Wert, der dem Bestand entspricht. */
+function deuten(roh) {
+    const daten = JSON.parse(ohneBom(roh));
+    return {
+        // Fehlt das Feld (state.json vor E69), ist es die erste Fassung: alles ohne Bundles.
+        // Geschrieben wird danach in der aktuellen Fassung, ein Rückweg ist nicht vorgesehen.
+        fassung: typeof daten.fassung === 'number' ? daten.fassung : 1,
+        quellen: (daten.quellen ?? []),
+        arbeitsverzeichnisse: (daten.arbeitsverzeichnisse ?? []),
+        bindungen: (daten.bindungen ?? []),
+        // Fehlt das Feld (state.json vor E38), gilt der bisherige Ist-Zustand: nur claude-code aktiv.
+        aktiveHarnesses: (daten.aktiveHarnesses ?? ['claude-code']),
+        // Fehlt das Feld (state.json vor E43), gilt: nichts ignoriert.
+        ignorierteEintraege: (daten.ignorierteEintraege ?? []),
+        // Fehlt das Feld (state.json vor E69), gilt: kein Bundle installiert.
+        bundleInstallationen: (daten.bundleInstallationen ?? []),
+        // Fehlt das Feld (state.json vor E78), gilt: jeder Harness hat nur sein Standard-Homedir.
+        harnessHeime: (daten.harnessHeime ?? []),
+    };
+}
 export class ZustandJson {
     pfad;
     constructor(pfad) {
@@ -12,19 +33,26 @@ export class ZustandJson {
         const roh = await readFile(this.pfad, 'utf8').catch(() => undefined);
         if (roh === undefined)
             return leererZustand();
-        const daten = JSON.parse(ohneBom(roh));
-        return {
-            quellen: (daten.quellen ?? []),
-            arbeitsverzeichnisse: (daten.arbeitsverzeichnisse ?? []),
-            bindungen: (daten.bindungen ?? []),
-            // Fehlt das Feld (state.json vor E38), gilt der bisherige Ist-Zustand: nur claude-code aktiv.
-            aktiveHarnesses: (daten.aktiveHarnesses ?? ['claude-code']),
-            // Fehlt das Feld (state.json vor E43), gilt: nichts ignoriert.
-            ignorierteEintraege: (daten.ignorierteEintraege ?? []),
-        };
+        return deuten(roh);
+    }
+    /**
+     * Derselbe Zustand, synchron gelesen (E78). Nötig für die Auflösung der Homedirs: sie hängt an
+     * `HarnessTyp.zielVerzeichnis`, und das ist synchron. Ein kaputter oder fehlender Zustand ergibt
+     * hier den leeren — die Homedir-Auflösung darf keine Ansicht abbrechen, sie fällt dann auf das
+     * Home des Nutzers zurück. Nicht Teil von `ZustandPort`: dort bleibt alles asynchron.
+     */
+    lesenSync() {
+        try {
+            return deuten(readFileSync(this.pfad, 'utf8'));
+        }
+        catch {
+            return leererZustand();
+        }
     }
     async schreiben(zustand) {
         await mkdir(path.dirname(this.pfad), { recursive: true });
-        await writeFile(this.pfad, `${JSON.stringify(zustand, null, 2)}\n`);
+        // Immer in der aktuellen Fassung, egal welche gelesen wurde: das Lesen hat den Bestand schon
+        // auf die aktuelle Form gebracht, ein alter Vermerk in der Datei wäre danach eine Lüge.
+        await writeFile(this.pfad, `${JSON.stringify({ ...zustand, fassung: ZUSTAND_FASSUNG }, null, 2)}\n`);
     }
 }