hmgr 0.0.46 → 0.0.48

package/dist/adapter/atomar-schreiben.js

@@ -0,0 +1,33 @@
+// Atomares Schreiben für Zustandsdateien (state.json, verlauf.json): Inhalt in eine Temp-Datei im
+// selben Verzeichnis, dann rename über das Ziel. Ein Leser (GUI-Intervall, CLI in einer anderen
+// Sitzung) sieht so immer den alten oder den neuen vollständigen Inhalt, nie eine leere oder halbe Datei.
+import { randomBytes } from 'node:crypto';
+import { rename, rm, writeFile } from 'node:fs/promises';
+/** Unter Windows scheitert rename über eine Datei, die ein anderer Prozess gerade offen hat, mit diesen Codes. */
+const WIEDERHOLBAR = new Set(['EPERM', 'EACCES', 'EBUSY']);
+const VERSUCHE = 5;
+async function warten(ms) {
+    await new Promise((r) => setTimeout(r, ms));
+}
+export async function atomarSchreiben(ziel, inhalt) {
+    const temp = `${ziel}.${process.pid}.${randomBytes(4).toString('hex')}.tmp`;
+    try {
+        await writeFile(temp, inhalt);
+        for (let versuch = 1;; versuch++) {
+            try {
+                await rename(temp, ziel);
+                return;
+            }
+            catch (fehler) {
+                const code = fehler.code;
+                if (versuch >= VERSUCHE || code === undefined || !WIEDERHOLBAR.has(code))
+                    throw fehler;
+                await warten(20 * versuch);
+            }
+        }
+    }
+    catch (fehler) {
+        await rm(temp, { force: true });
+        throw fehler;
+    }
+}

package/dist/adapter/git.js

@@ -1,7 +1,9 @@
 // Git über die CLI, keine Bibliothek. Checkout-Schema und Worktrees nach E22, Discovery nach E11.
 import { spawn } from 'node:child_process';
-import { readFile, readdir, mkdir, realpath, rm, stat } from 'node:fs/promises';
+import { readFile, readdir, mkdir, realpath, rm, stat, writeFile } from 'node:fs/promises';
+import { homedir } from 'node:os';
 import path from 'node:path';
+import { SOPS_FILTER, SOPS_MARKE, checkAttrLesen, filterBefehle, musterAuswahl, probe, sopsFehlertext, standardSops, wrapperFinden, } from "./sops.js";
 import { bundleLesen, istBundleDatei } from "./bundle-yaml.js";
 import { marketplaceLesen } from "./marketplace-json.js";
 import { SKILL_DATEI, skillAusPfad, skillName } from "./skill-md.js";
@@ -131,9 +133,11 @@ const SPERRE_BELEGT = /Unable to create '[^']+\.lock': File exists/;
 export class GitQuellen {
     wurzel;
     sperreWartezeitenMs;
+    sops;
     constructor(wurzel, optionen = {}) {
         this.wurzel = wurzel;
         this.sperreWartezeitenMs = optionen.sperreWartezeitenMs ?? SPERRE_WARTEZEITEN_MS;
+        this.sops = optionen.sops ?? standardSops(homedir());
     }
     /**
      * Wiederholt einen git-Aufruf, wenn eine fremde Sperre ihn blockiert (E99): GUI-Aktionen und der
@@ -379,15 +383,10 @@ export class GitQuellen {
     async checkout(quelle, ref, skills) {
         // Lokale Quellen werden nicht geklont, der Pfad selbst ist der Checkout (B11).
         if (quelle.art === 'lokal')
-            return { quelle, ref, pfad: quelle.pfad };
+            return { quelle, ref, pfad: quelle.pfad, sopsVerschluesselt: [] };
         const basis = await this.basis(quelle);
         const pfad = worktreePfad(this.wurzel, quelleZerlegen(quelle), ref);
         const neu = !(await existiert(pfad));
-        if (neu) {
-            await mkdir(path.dirname(pfad), { recursive: true });
-            await this.git(['worktree', 'add', '--detach', '--no-checkout', pfad, ref], basis);
-            await this.git(['sparse-checkout', 'init', '--no-cone'], pfad);
-        }
         const vorhanden = neu
             ? []
             : (await this.git(['sparse-checkout', 'list'], pfad)).split('\n').filter((z) => z.length > 0);
@@ -404,10 +403,201 @@ export class GitQuellen {
         // stört nicht — wohl aber sähe ein Nutzer, der den Link im Finder öffnet, den vollen Worktree.
         for (const skill of skills)
             muster.add(skill.pfad === '' ? '/**' : `/${skill.pfad}/`);
+        // SOPS-Filter vor dem ersten Schreiben (E115): `sparse-checkout set` und `checkout` schreiben
+        // die Dateien, ein später gesetzter Filter ändert an ihnen nichts mehr. Ein bestehender
+        // Worktree steht auf seinem eigenen HEAD, ein neuer kommt auf `ref`.
+        const sopsVerschluesselt = await this.sopsVorbereiten(neu ? basis : pfad, neu ? ref : 'HEAD', basis, muster);
+        if (neu) {
+            await mkdir(path.dirname(pfad), { recursive: true });
+            await this.git(['worktree', 'add', '--detach', '--no-checkout', pfad, ref], basis);
+            await this.git(['sparse-checkout', 'init', '--no-cone'], pfad);
+        }
         await this.git(['sparse-checkout', 'set', '--no-cone', '--', ...muster], pfad);
         if (neu)
             await this.git(['checkout', '--detach', ref], pfad);
-        return { quelle, ref, pfad };
+        return { quelle, ref, pfad, sopsVerschluesselt };
+    }
+    /**
+     * Dateien eines Refs unter einem SOPS-Filter, den hmgr kennt (E115), beschränkt auf `auswahl`.
+     * Der Normalfall kostet einen `ls-tree`: ohne `.gitattributes`, die für eine gewählte Datei
+     * gelten kann, oder ohne „sops_" darin endet die Suche dort. Erst dann `check-attr`, mit
+     * `--source` (git ≥ 2.40), weil der Basis-Clone bare ist und ein neuer Worktree noch leer.
+     * Scheitert ein Aufruf (etwa ein älteres git), gilt die Liste als leer: dann bleibt es beim
+     * Auschecken wie vor E115.
+     */
+    async sopsKandidaten(cwd, ref, auswahl) {
+        try {
+            const alle = (await this.git(['ls-tree', '-r', '-z', '--name-only', ref], cwd)).split('\0').filter((z) => z.length > 0);
+            const istAttribute = (d) => d === '.gitattributes' || d.endsWith('/.gitattributes');
+            const gewaehlt = alle.filter((d) => auswahl(d) && !istAttribute(d));
+            if (gewaehlt.length === 0)
+                return [];
+            // Eine .gitattributes gilt für ihr Verzeichnis und alles darunter.
+            const attribute = alle.filter((d) => {
+                if (!istAttribute(d))
+                    return false;
+                const verzeichnis = d.slice(0, -'.gitattributes'.length);
+                return gewaehlt.some((g) => g.startsWith(verzeichnis));
+            });
+            if (attribute.length === 0)
+                return [];
+            const inhalte = await this.dateiInhalte(cwd, ref, attribute);
+            if (![...inhalte.values()].some((text) => text.includes('sops_')))
+                return [];
+            const ausgabe = await this.gitMitEingabe(['check-attr', `--source=${ref}`, '-z', '--stdin', 'filter'], cwd, `${gewaehlt.join('\0')}\0`);
+            const werte = checkAttrLesen(ausgabe.toString('utf8'));
+            return gewaehlt
+                .map((datei) => ({ datei, filter: werte.get(datei) ?? '' }))
+                .filter((k) => SOPS_FILTER.includes(k.filter));
+        }
+        catch {
+            return [];
+        }
+    }
+    /** Ob `filter.<name>.smudge` wirksam gesetzt ist, global oder im Basis-Clone (E115). */
+    async filterGesetzt(basis, name) {
+        const wert = await this.git(['config', '--get', `filter.${name}.smudge`], basis).catch(() => '');
+        return wert.trim().length > 0;
+    }
+    /** Filter wie sops-setup.sh im Basis-Clone setzen; er gilt für alle Worktrees der Quelle (E115). */
+    async filterSetzen(basis, namen, wrapper) {
+        const { clean, smudge } = filterBefehle(this.sops.programm, wrapper);
+        for (const name of namen) {
+            await this.git(['config', `filter.${name}.clean`, clean], basis);
+            await this.git(['config', `filter.${name}.smudge`, smudge], basis);
+            await this.git(['config', `filter.${name}.required`, 'true'], basis);
+        }
+    }
+    /**
+     * Probe über alle Dateien, Abbruch beim ersten Fehlschlag (E115): nur wenn alle klappen, kommen
+     * Filter in Frage. Ein Fehlschlag gilt für alle, denn ohne Filter bleiben alle verschlüsselt.
+     */
+    async sopsProbe(cwd, ref, dateien) {
+        const inhalte = await this.dateiInhalte(cwd, ref, dateien);
+        for (const datei of dateien) {
+            const inhalt = inhalte.get(datei);
+            if (inhalt === undefined)
+                return 'entschluesselung-scheitert';
+            const ergebnis = await probe(this.sops.programm, datei, inhalt);
+            if (!ergebnis.ok)
+                return ergebnis.grund;
+        }
+        return undefined;
+    }
+    /**
+     * Vor dem Schreiben eines Checkouts (E115): SOPS-Dateien unter den Mustern finden, für Filter,
+     * die noch nicht wirksam sind, die Probe machen und bei Erfolg die Filter setzen. Ein schon
+     * gesetzter Filter (global oder lokal) bleibt unangetastet und braucht keine Probe. Ergebnis:
+     * die Dateien, die verschlüsselt ankommen werden.
+     */
+    async sopsVorbereiten(cwd, ref, basis, muster) {
+        const kandidaten = await this.sopsKandidaten(cwd, ref, musterAuswahl(muster));
+        if (kandidaten.length === 0)
+            return [];
+        const offen = [];
+        for (const name of new Set(kandidaten.map((k) => k.filter)))
+            if (!(await this.filterGesetzt(basis, name)))
+                offen.push(name);
+        if (offen.length === 0)
+            return [];
+        const betroffen = kandidaten.filter((k) => offen.includes(k.filter)).map((k) => k.datei);
+        // Ohne sops-clean.sh keine Filter (F140): git hielte die entschlüsselte Datei sonst sofort für
+        // geändert (echtes `sops --encrypt` verschlüsselt jedes Mal anders). Die Probe entfällt dann.
+        const wrapper = await wrapperFinden(this.sops.wrapperKandidaten);
+        if (wrapper === undefined)
+            return betroffen.map((datei) => ({ datei, grund: 'wrapper-fehlt' }));
+        const grund = await this.sopsProbe(cwd, ref, betroffen);
+        if (grund !== undefined)
+            return betroffen.map((datei) => ({ datei, grund }));
+        await this.filterSetzen(basis, offen, wrapper);
+        return [];
+    }
+    /** SOPS-Dateien eines bestehenden Worktrees samt Inhalt auf der Platte (E115). */
+    async sopsAufPlatte(checkout) {
+        if (checkout.quelle.art === 'lokal' || !(await existiert(checkout.pfad)))
+            return [];
+        const kandidaten = await this.sopsKandidaten(checkout.pfad, 'HEAD', () => true);
+        const ergebnis = [];
+        for (const kandidat of kandidaten) {
+            // Was der Sparse-Checkout nicht geschrieben hat, liegt nicht auf der Platte und zählt nicht.
+            const inhalt = await readFile(path.join(checkout.pfad, kandidat.datei), 'utf8').catch(() => undefined);
+            if (inhalt !== undefined)
+                ergebnis.push({ ...kandidat, inhalt });
+        }
+        return ergebnis;
+    }
+    async sopsDateien(checkout) {
+        return (await this.sopsAufPlatte(checkout)).map((k) => ({
+            datei: k.datei,
+            verschluesselt: k.inhalt.includes(SOPS_MARKE),
+        }));
+    }
+    /**
+     * Bestand (E115): eine SOPS-Datei, die vor E115 verschlüsselt ankam, bleibt so, denn git hält
+     * sie für unverändert. Wo die Probe klappt: Filter setzen (falls noch nicht wirksam), Datei
+     * löschen, `git checkout -- <datei>` schreibt sie durch den smudge-Filter neu. Danach muss sie
+     * Klartext sein und `git status` für sie leer, sonst gilt das Neuschreiben als gescheitert.
+     * Eine Datei, die nicht mehr dem Commit entspricht (von Hand geändert), fasst hmgr nicht an —
+     * verglichen werden die Bytes mit dem Blob, unabhängig von Filtern. Scheitert `checkout`, kommt
+     * der alte Inhalt zurück, damit nie eine Datei fehlt.
+     */
+    async sopsReparieren(checkout) {
+        if (checkout.quelle.art === 'lokal')
+            return [];
+        const verschluesselt = (await this.sopsAufPlatte(checkout)).filter((k) => k.inhalt.includes(SOPS_MARKE));
+        if (verschluesselt.length === 0)
+            return [];
+        const ergebnis = [];
+        const blobs = await this.dateiInhalte(checkout.pfad, 'HEAD', verschluesselt.map((k) => k.datei));
+        const unveraendert = verschluesselt.filter((k) => {
+            if (blobs.get(k.datei) === k.inhalt)
+                return true;
+            ergebnis.push({ datei: k.datei, ergebnis: 'verschluesselt', grund: 'lokale-aenderung' });
+            return false;
+        });
+        if (unveraendert.length === 0)
+            return ergebnis;
+        const basis = await this.basis(checkout.quelle);
+        const offen = [];
+        for (const name of new Set(unveraendert.map((k) => k.filter)))
+            if (!(await this.filterGesetzt(basis, name)))
+                offen.push(name);
+        // Müssen Filter erst gesetzt werden, braucht es sops-clean.sh (F140), sonst bleibt alles, wie es ist.
+        const wrapper = offen.length === 0 ? undefined : await wrapperFinden(this.sops.wrapperKandidaten);
+        if (offen.length > 0 && wrapper === undefined) {
+            for (const k of unveraendert)
+                ergebnis.push({ datei: k.datei, ergebnis: 'verschluesselt', grund: 'wrapper-fehlt' });
+            return ergebnis;
+        }
+        const grund = await this.sopsProbe(checkout.pfad, 'HEAD', unveraendert.map((k) => k.datei));
+        if (grund !== undefined) {
+            for (const k of unveraendert)
+                ergebnis.push({ datei: k.datei, ergebnis: 'verschluesselt', grund });
+            return ergebnis;
+        }
+        if (wrapper !== undefined)
+            await this.filterSetzen(basis, offen, wrapper);
+        for (const k of unveraendert) {
+            const datei = path.join(checkout.pfad, k.datei);
+            try {
+                await rm(datei, { force: true });
+                await this.git(['checkout', '--', k.datei], checkout.pfad);
+            }
+            catch (fehler) {
+                await writeFile(datei, k.inhalt);
+                ergebnis.push({ datei: k.datei, ergebnis: 'fehlgeschlagen', fehler: fehler instanceof Error ? fehler.message : String(fehler) });
+                continue;
+            }
+            const neu = await readFile(datei, 'utf8').catch(() => undefined);
+            const status = await this.git(['--no-optional-locks', 'status', '--porcelain', '--', k.datei], checkout.pfad).catch(() => 'unlesbar');
+            if (neu === undefined || neu.includes(SOPS_MARKE))
+                ergebnis.push({ datei: k.datei, ergebnis: 'fehlgeschlagen', fehler: 'nach dem Neuschreiben noch verschlüsselt' });
+            else if (status.trim().length > 0)
+                ergebnis.push({ datei: k.datei, ergebnis: 'fehlgeschlagen', fehler: 'git meldet die Datei danach als geändert' });
+            else
+                ergebnis.push({ datei: k.datei, ergebnis: 'repariert' });
+        }
+        return ergebnis;
     }
     /**
      * Alle Checkouts unter der Wurzel, aus dem Dateisystem gelesen (E19). Die Quelle kommt aus der
@@ -446,7 +636,15 @@ export class GitQuellen {
     async aktualisieren(checkout) {
         if (checkout.quelle.art === 'lokal')
             return { ergebnis: 'unveraendert' };
-        if (await this.lokaleAenderungen(checkout))
+        // Auch `status` kann an einem SOPS-Filter scheitern (E115): nur dieser Checkout schlägt fehl.
+        let lokalGeaendert;
+        try {
+            lokalGeaendert = await this.lokaleAenderungen(checkout);
+        }
+        catch (fehler) {
+            return { ergebnis: 'fehlgeschlagen', fehler: sopsFehlertext(fehler) };
+        }
+        if (lokalGeaendert)
             return { ergebnis: 'uebersprungen', grund: 'lokale-aenderung' }; // E15
         const basis = await this.basis(checkout.quelle);
         const von = (await this.git(['rev-parse', 'HEAD'], checkout.pfad)).trim();
@@ -460,7 +658,14 @@ export class GitQuellen {
         const nach = (await this.git(['rev-parse', checkout.ref], basis)).trim();
         if (von === nach)
             return { ergebnis: 'unveraendert' };
-        await this.git(['checkout', '--detach', checkout.ref], checkout.pfad);
+        try {
+            await this.git(['checkout', '--detach', checkout.ref], checkout.pfad);
+        }
+        catch (fehler) {
+            // Ein required-Filter, der nicht entschlüsseln kann, bricht das Nachziehen ab (E115). Das
+            // trifft nur diesen Checkout, die übrigen laufen weiter.
+            return { ergebnis: 'fehlgeschlagen', fehler: sopsFehlertext(fehler) };
+        }
         return { ergebnis: 'aktualisiert', von, nach };
     }
     /**

package/dist/adapter/sops.js

@@ -0,0 +1,107 @@
+// SOPS-Filter für Checkouts (E115): Probe-Entschlüsselung, Filterbefehle und das Lesen von
+// `git check-attr`. Die Filter selbst setzt GitQuellen (git.ts) im Basis-Clone; hier liegt nur, was
+// ohne git auskommt. Vorlage der Filterbefehle: sops-setup.sh im Skill sops-secrets-manager.
+import { spawn } from 'node:child_process';
+import { access, constants } from 'node:fs/promises';
+import path from 'node:path';
+/** Die Filternamen, die hmgr kennt und selbst einrichtet (E115). */
+export const SOPS_FILTER = ['sops_dotenv', 'sops_yaml', 'sops_generic'];
+/** Woran hmgr eine noch verschlüsselte SOPS-Datei im Arbeitsbaum erkennt. */
+export const SOPS_MARKE = 'ENC[';
+/** Die Einstellung im Betrieb: sops vom PATH, sops-clean.sh unter /usr/local/bin oder ~/bin. */
+export function standardSops(home) {
+    return {
+        programm: 'sops',
+        wrapperKandidaten: ['/usr/local/bin/sops-clean.sh', path.join(home, 'bin', 'sops-clean.sh')],
+    };
+}
+/**
+ * Ein Wort für die Shell, die git für Filterbefehle startet: unverändert, wenn nichts darin die
+ * Shell stört, sonst in einfachen Anführungszeichen. So bricht ein Home-Pfad mit Leerzeichen nicht.
+ */
+export function shellWort(wert) {
+    if (/^[A-Za-z0-9_@%+=:,./-]+$/.test(wert))
+        return wert;
+    return `'${wert.replace(/'/g, `'\\''`)}'`;
+}
+/** clean- und smudge-Befehl wie sops-setup.sh; `%f` setzt git selbst (schon für die Shell gequotet). */
+export function filterBefehle(programm, wrapper) {
+    const sops = shellWort(programm);
+    const verschluesseln = `${sops} --encrypt --filename-override %f /dev/stdin`;
+    return {
+        clean: wrapper === undefined ? verschluesseln : `${shellWort(wrapper)} %f ${verschluesseln}`,
+        smudge: `${sops} --decrypt --filename-override %f /dev/stdin`,
+    };
+}
+/** Der erste ausführbare Kandidat für sops-clean.sh, sonst undefined. */
+export async function wrapperFinden(kandidaten) {
+    for (const kandidat of kandidaten) {
+        const ausfuehrbar = await access(kandidat, constants.X_OK).then(() => true, () => false);
+        if (ausfuehrbar)
+            return kandidat;
+    }
+    return undefined;
+}
+/**
+ * Entschlüsselt `inhalt` probeweise so, wie es der smudge-Filter täte. Der Klartext wird verworfen,
+ * es zählt nur der Exit-Code. Fehlt das Programm, heißt das „sops fehlt", kein Absturz.
+ */
+export async function probe(programm, datei, inhalt) {
+    return await new Promise((erfuellen) => {
+        let fertig = false;
+        const ende = (ergebnis) => {
+            if (fertig)
+                return;
+            fertig = true;
+            erfuellen(ergebnis);
+        };
+        const kind = spawn(programm, ['--decrypt', '--filename-override', datei, '/dev/stdin'], {
+            stdio: ['pipe', 'ignore', 'ignore'],
+            timeout: 60_000,
+            killSignal: 'SIGKILL',
+        });
+        kind.on('error', (fehler) => ende({ ok: false, grund: fehler.code === 'ENOENT' ? 'sops-fehlt' : 'entschluesselung-scheitert' }));
+        kind.on('close', (code) => ende(code === 0 ? { ok: true } : { ok: false, grund: 'entschluesselung-scheitert' }));
+        // Endet sops vor dem Lesen, schreibt Node in eine geschlossene Pipe: das ist kein eigener Fehler.
+        kind.stdin.on('error', () => { });
+        kind.stdin.end(inhalt);
+    });
+}
+/**
+ * Fehlertext für einen gescheiterten git-Aufruf beim Nachziehen (E115): Scheitert er an einem
+ * SOPS-Filter, steht vorn ein verständlicher Satz, die Meldung von git folgt dahinter.
+ */
+export function sopsFehlertext(fehler) {
+    const meldung = fehler instanceof Error ? fehler.message : String(fehler);
+    // git meldet je nach Sprache anders; sicher drin stehen der Filtername oder der sops-Befehl.
+    if (!/sops_(?:dotenv|yaml|generic)|--decrypt --filename-override/.test(meldung))
+        return meldung;
+    return `Eine mit SOPS verschlüsselte Datei ließ sich nicht entschlüsseln (sops fehlt oder der Schlüssel passt nicht), dieser Checkout wurde nicht nachgezogen. git meldet: ${meldung}`;
+}
+/** Ausgabe von `git check-attr -z … filter`: je Datei drei NUL-getrennte Felder Pfad, Attribut, Wert. */
+export function checkAttrLesen(ausgabe) {
+    const teile = ausgabe.split('\0');
+    const ergebnis = new Map();
+    for (let i = 0; i + 2 < teile.length; i += 3)
+        ergebnis.set(teile[i], teile[i + 2]);
+    return ergebnis;
+}
+/**
+ * Welche Dateien ein Sparse-Checkout mit diesen Mustern schreibt (E11): `/*` die Dateien an der
+ * Wurzel, `/**` alles, `/<pfad>/` alles darunter. Ausschlüsse (`!…`) nehmen nur Verzeichnisse an
+ * der Wurzel heraus, die über `/*` ohnehin nicht als Datei zählen.
+ */
+export function musterAuswahl(muster) {
+    let wurzelDateien = false;
+    let alles = false;
+    const praefixe = [];
+    for (const m of muster) {
+        if (m === '/*')
+            wurzelDateien = true;
+        else if (m === '/**')
+            alles = true;
+        else if (!m.startsWith('!') && m.startsWith('/') && m.endsWith('/') && m.length > 2)
+            praefixe.push(m.slice(1));
+    }
+    return (datei) => alles || (wurzelDateien && !datei.includes('/')) || praefixe.some((praefix) => datei.startsWith(praefix));
+}

package/dist/adapter/verlauf-json.js

@@ -1,8 +1,9 @@
 // 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 { mkdir, readFile } from 'node:fs/promises';
 import path from 'node:path';
 import { leererVerlauf } from "../ports/verlauf.js";
+import { atomarSchreiben } from "./atomar-schreiben.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;
@@ -34,6 +35,6 @@ export class VerlaufJson {
         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`);
+        await atomarSchreiben(this.pfad, `${JSON.stringify({ fassung: 1, ...gekappt }, null, 2)}\n`);
     }
 }

package/dist/adapter/zustand-json.js

@@ -1,8 +1,9 @@
 // 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 { mkdir, readFile } from 'node:fs/promises';
 import path from 'node:path';
 import { ZUSTAND_FASSUNG, leererZustand, } from "../ports/zustand.js";
+import { atomarSchreiben } from "./atomar-schreiben.js";
 import { ohneBom } from "./datei-text.js";
 /** Der gelesene Text als Zustand. Fehlende Felder bekommen den Wert, der dem Bestand entspricht. */
 function deuten(roh) {
@@ -54,6 +55,6 @@ export class ZustandJson {
         await mkdir(path.dirname(this.pfad), { recursive: true });
         // 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`);
+        await atomarSchreiben(this.pfad, `${JSON.stringify({ ...zustand, fassung: ZUSTAND_FASSUNG }, null, 2)}\n`);
     }
 }

package/dist/aenderungen.json

@@ -1,6 +1,12 @@
 {
   "fassung": 1,
   "versionen": {
+    "0.0.48": [
+      "Die Meldung „Unexpected end of JSON input“ taucht nicht mehr auf, wenn hmgr an mehreren Stellen gleichzeitig läuft, etwa die Oberfläche und die Kommandozeile: hmgr schreibt seinen Zustand und den Verlauf jetzt so, dass nie eine halb geschriebene Datei gelesen wird."
+    ],
+    "0.0.47": [
+      "Skills mit SOPS-verschlüsselten Dateien kommen jetzt entschlüsselt an, wenn sops, der passende Schlüssel und sops-clean.sh vorhanden sind; bereits verschlüsselt ausgecheckte Dateien repariert hmgr beim nächsten Aktualisieren. Klappt das nicht, bleibt die Datei verschlüsselt und hmgr sagt im Verlauf und in hmgr status, warum."
+    ],
     "0.0.46": [
       "Bundles lassen sich aufklappen und zeigen ihre Skills mit Beschreibung, auch schon im Dialog „Skills hinzufügen“. Entfernst du einen einzelnen Skill, bleibt das Bundle bestehen und zeigt, was fehlt; mit „Vervollständigen“ oder „Wieder verlinken“ holst du Skills zurück, und „Entfernen“ am Bundle räumt den Rest weg."
     ],

package/dist/cli/hilfe.js

@@ -531,7 +531,9 @@ ohne den übrigen Lauf aufzuhalten. hmgr bundle sync macht dasselbe für ein ein
 Danach räumt update verwaiste Ref-Verzeichnisse auf: Checkouts, in die kein Link mehr zeigt, weil
 ein Link inzwischen auf einen anderen Ref umgelegt wurde. Vor dem Löschen fragt hmgr einmal für
 alle Kandidaten. Ohne Bestätigung, also auch ohne Terminal, bleibt alles liegen und wird nur
-gemeldet. Ein verwaister Checkout mit lokaler Änderung wird nie gelöscht (E15).
+gemeldet. Ein verwaister Checkout mit lokaler Änderung wird nie gelöscht (E15). Danach folgen die
+Prüfungen von hmgr doctor: fehlende Arbeitsverzeichnisse und mit SOPS verschlüsselte Dateien, die
+noch verschlüsselt im Checkout liegen (siehe hmgr help doctor).
 
 So wird eine Änderung an einem Skill überall wirksam: in der Quelle committen und pushen, dann
 hmgr update.
@@ -551,7 +553,8 @@ Eingeschränkter Lauf (E89): hmgr update <skill> zieht nur die Quelle nach, in d
 von URL, Pfad oder Anzeigenamen der Quelle, Groß- und Kleinschreibung egal; passt keine oder
 mehr als eine, bricht update mit der Liste ab. Beides zusammen geht nicht. Der Lauf umfasst die
 Checkouts dieser Quelle und die Bundles, deren Definition in ihr liegt. Es entfallen: Plugins,
-Aufräumen verwaister Checkouts, der Check auf fehlende Arbeitsverzeichnisse (doctor) sowie alle
+Aufräumen verwaister Checkouts, die doctor-Prüfungen (fehlende Arbeitsverzeichnisse,
+verschlüsselte SOPS-Dateien) sowie alle
 übrigen Quellen und Bundles. Der Verlaufseintrag entsteht wie im vollen Lauf.
 
 Schalter:
@@ -587,7 +590,10 @@ ausgecheckte Skills (E70). Quellen ohne Skill-Änderung sammelt eine Zeile am En
 Ereignisse, je eine Zeile: ein nachgezogenes Bundle mit gelegten und entfernten Links, ein
 aufgeräumter (gelöschter) Checkout, ein Fehler zu einer Quelle oder einem Bundle, dazu
 hmgr-Ereignisse: ein Versionssprung von hmgr selbst (GUI oder CLI, erkannt beim Start bzw. bei
-jedem CLI-Aufruf) oder ein gefundenes Update, das noch nicht installiert ist. Einträge aus der
+jedem CLI-Aufruf) oder ein gefundenes Update, das noch nicht installiert ist. Dazu Dateien, die
+eine Quelle mit SOPS verschlüsselt: eine, die verschlüsselt im Checkout blieb, mit Grund (einmal,
+auch direkt nach einem hmgr link), und eine, die hmgr nachträglich entschlüsselt hat (siehe
+hmgr help doctor). Einträge aus der
 Zeit vor E109 zeigen nur „Geändert". Plugins stehen nicht im Verlauf (siehe hmgr help update).
 
 Unter einem „installiert"-Eintrag von hmgr stehen die Änderungen: je Version seit der zuvor
@@ -611,8 +617,21 @@ Prüft, ob jedes gemerkte Arbeitsverzeichnis (hmgr dir add) noch auf der Platte
 umbenanntes oder woanders neu geklontes Projekt hinterlässt sonst für immer einen toten Pfad im
 Zustand, den nur hmgr dir forget von Hand entfernt. Bei einem Fund fragt doctor wie hmgr update
 einmal für alle Funde, ob sie vergessen werden sollen; ohne Bestätigung bleiben sie gemeldet, aber
-gemerkt. Anders als update holt doctor nichts aus dem Netz und schreibt keinen Eintrag in den
-Verlauf — ein reiner Konsolen-Check, kein Lauf im E80-Sinn.
+gemerkt. Anders als update holt doctor nichts aus dem Netz.
+
+Dazu prüft doctor Dateien, die eine Quelle mit SOPS verschlüsselt (.gitattributes mit
+filter=sops_dotenv, sops_yaml oder sops_generic) und die noch verschlüsselt im Checkout liegen,
+etwa weil sie vor dieser Prüfung ausgecheckt wurden oder sops damals fehlte. Liegt
+sops-clean.sh unter /usr/local/bin oder ~/bin und klappt eine probeweise Entschlüsselung mit sops,
+richtet doctor die git-Filter für die Quelle ein (wie sops-setup.sh, mit sops-clean.sh) und
+schreibt die Datei entschlüsselt neu. Sonst bleibt die Datei, wie sie ist, und doctor nennt den
+Grund: sops-clean.sh fehlt, sops fehlt, der Schlüssel passt nicht, oder die Datei ist im Checkout
+von Hand geändert. Ohne sops-clean.sh richtet hmgr nie Filter ein, weil git die entschlüsselte
+Datei sonst sofort für geändert hielte und hmgr update den Checkout danach immer überspränge.
+Dieselbe Regel gilt schon beim ersten Auschecken (hmgr link).
+Diese Befunde stehen auch im Verlauf (hmgr log), eine verschlüsselt gebliebene Datei nur einmal.
+Fehlende Arbeitsverzeichnisse schreibt doctor nicht in den Verlauf. hmgr update macht dieselbe
+Prüfung im selben Lauf.
 
 Schalter: keine.
 
@@ -622,6 +641,11 @@ Beispiel:
 Häufige Fälle:
   „liegen lassen … ohne Bestätigung nicht vergessen": die Frage kam ohne Ja zurück. In einem
   Terminal erneut hmgr doctor aufrufen, oder hmgr dir forget <pfad> gezielt.
+  „verschlüsselt … sops-clean.sh fehlt": sops-clean.sh ausführbar nach ~/bin oder
+  /usr/local/bin legen, dann erneut hmgr doctor.
+  „verschlüsselt … sops ist auf diesem Rechner nicht installiert": sops installieren, dann erneut
+  hmgr doctor. „… vermutlich fehlt der passende Schlüssel": der Schlüssel dieses Rechners steht
+  nicht unter den Empfängern der Datei, oder sops findet ihn nicht.
 
 Siehe auch: hmgr help update, hmgr help dir`;
 const STATUS = `hmgr status
@@ -631,7 +655,8 @@ und Ref, davor die Versionseinschränkung, falls der Zeiger eine nennt. Dahinter
 abgeleitete Grund des Links: das Plugin, zu dem er gehört, oder „über Zeiger", von Hand gelegte
 Links bleiben ohne Zusatz. Fremde Einträge und Links ohne bekannte Quelle sind eigens
 gekennzeichnet, dazu kommen die Plugins des Ziels. Am Ende stehen die Harnesses, die auf diesem
-Rechner nicht liegen.
+Rechner nicht liegen, und, falls es welche gibt, mit SOPS verschlüsselte Dateien, die noch
+verschlüsselt im Checkout liegen. status repariert nichts, das macht hmgr doctor.
 
 Schalter: keine.
 
@@ -644,10 +669,12 @@ Häufige Fälle:
   Zustand steht. Mit hmgr source add <url> die Quelle wieder eintragen.
   „Nicht vorhanden": der Harness hat sein Verzeichnis auf diesem Rechner nicht angelegt, hmgr
   überspringt seine Ziele.
+  „Noch verschlüsselt im Checkout": hmgr doctor versucht, die Datei zu entschlüsseln, und nennt
+  den Grund, wenn es nicht klappt.
   Ein Ziel fehlt: Ziele inaktiver Harness-Typen zeigt status nicht, auch wenn dort noch Links
   liegen. hmgr harness list zeigt den Stand, hmgr harness enable <name> holt die Ziele zurück.
 
-Siehe auch: hmgr help adopt, hmgr help sync`;
+Siehe auch: hmgr help adopt, hmgr help sync, hmgr help doctor`;
 const HARNESS = `hmgr harness list
 hmgr harness enable <name>
 hmgr harness disable <name>

package/dist/cli/main.js

@@ -4,7 +4,7 @@ import path from 'node:path';
 import { realpathSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { pathToFileURL } from 'node:url';
-import { checkoutGruppen, quellenAnzeigeName, sammelZeile, verlaufZeitpunkt } from "./verlauf-anzeige.js";
+import { checkoutGruppen, quellenAnzeigeName, sammelZeile, sopsGrundText, sopsZeile, verlaufZeitpunkt, } from "./verlauf-anzeige.js";
 import { Anwendungsfaelle, pluginWeltText, } from "../kern/anwendungsfaelle.js";
 import { AbhaengigkeitFehlt, BundleDateiFehler, BundleMehrdeutig, BundleMitgliederFehlen, BundleNamenskonflikte, BundleNichtInstalliert, BundleUnbekannt, EinschraenkungOhneZeiger, HarnessInaktiv, HarnessNichtVorhanden, HarnessTypUnbekannt, HeimAdresseUngueltig, HeimBereitsVorhanden, HeimFaehigkeitFehlt, HeimNurUnterWindows, ClaudeCliNichtErreichbar, HeimUnbekannt, KeinPassenderRef, LinkAnlegenFehlgeschlagen, McpAbweichenderEintrag, McpEbeneNichtUnterstuetzt, McpFaehigkeitFehlt, McpKatalogFehler, McpNichtInGeteilterDatei, McpNurGeteilterFundort, McpOrtUnterGitWurzel, McpUebernahmeNichtMoeglich, McpUebernahmeUnvollstaendig, McpUnbekannt, NameBelegt, OrtNichtUnterstuetzt, PluginMehrdeutig, PluginUnbekannt, QuelleAufraeumenLokaleAenderungen, QuelleNameBelegt, QuelleUnbekannt, SkillMehrdeutig, SkillOrdnerBereitsVerwaltet, SkillOrdnerFaehigkeitFehlt, SkillOrdnerNichtVerwaltet, SkillOrdnerUngueltig, SkillUnbekannt, ZeigerMehrdeutig, WslBrueckeFehlgeschlagen, ZeigerSchreibenGesperrt, heimAdresseAlsText, heimAdresseZerlegen, wslDistroVonOrt, wslUncZerlegen, pluginSchluessel, quelleName, quelleSchluessel, } from "../kern/modell.js";
 import { Agents } from "../adapter/agents.js";
@@ -19,6 +19,7 @@ import { DateiMcpKatalog } from "../adapter/mcp-katalog.js";
 import { cliUpdateHinweis } from "../adapter/npm-registry.js";
 import { paketVersion } from "../adapter/paket-version.js";
 import { quelleAlsText, quelleAusText } from "../adapter/quelle-text.js";
+import { standardSops } from "../adapter/sops.js";
 import { TerminalRueckfrage } from "../adapter/terminal.js";
 import { ProzessUmgebung } from "../adapter/umgebung.js";
 import { signalSchreiben } from "../adapter/gui-signal.js";
@@ -92,7 +93,7 @@ export function bauen(umgebung, optionen = {}) {
     });
     const ports = {
         harnesses: [claude, new Hermes(heime, zugriffFuerOrt), new Agents(heime, zugriffFuerOrt)],
-        quellen: new GitQuellen(wurzel),
+        quellen: new GitQuellen(wurzel, { sops: optionen.sops ?? standardSops(umgebung.home) }),
         ziele: new DateisystemZiele(wurzel, zustand, umgebung.xdgStateHome, (ziel) => zugriffFuerOrt(ziel.ort)),
         zeiger: new ComposerZeiger(),
         zustand,
@@ -855,12 +856,17 @@ export async function ausfuehren(argv, umgebung, optionen = {}) {
             else
                 console.log(`  liegen lassen   Arbeitsverzeichnis ${pfad} (nicht mehr auf der Platte, ohne Bestätigung nicht vergessen)`);
         }
+        // SOPS-Dateien, die verschlüsselt im Checkout lagen (E115).
+        const sopsQuellen = doctor.sops.length === 0 ? [] : await anwendungsfaelle.quellen();
+        for (const zeile of sopsBerichtZeilen(doctor.sops, sopsQuellen))
+            console.log(zeile);
         // Die Sammelzeile steht ganz am Ende des Berichts (E109); „Außerdem" nur, wenn sonst etwas im Lauf stand.
         const updateSammel = sammelZeile(updateOhne, !updateAndere &&
             pluginFehler.length === 0 &&
             bundleBericht(bundles).length === 0 &&
             aufraeumen.verwaiste.length === 0 &&
-            doctor.fehlendeArbeitsverzeichnisse.length === 0);
+            doctor.fehlendeArbeitsverzeichnisse.length === 0 &&
+            doctor.sops.length === 0);
         if (updateSammel !== undefined)
             console.log(updateSammel);
         // Zuletzt hmgr selbst (E77): wer schon aktualisiert, will auch wissen, dass sein hmgr alt ist.
@@ -907,6 +913,15 @@ export async function ausfuehren(argv, umgebung, optionen = {}) {
         const fehlend = await anwendungsfaelle.nichtVorhandeneHarnesses();
         if (fehlend.length > 0)
             console.log(`Nicht vorhanden: ${fehlend.join(', ')}`);
+        // SOPS-Dateien, die noch verschlüsselt im Checkout liegen (E115); ohne Fund keine Zeile.
+        const verschluesselt = await anwendungsfaelle.sopsVerschluesselteDateien();
+        if (verschluesselt.length > 0) {
+            const quellen = await anwendungsfaelle.quellen();
+            console.log('Noch verschlüsselt im Checkout:');
+            for (const { checkout, datei } of verschluesselt)
+                console.log(`  ${datei} aus ${quellenAnzeigeName({ quelle: quelleAlsText(checkout.quelle), ref: checkout.ref }, quellen)}  (${path.join(checkout.pfad, datei)})`);
+            console.log('hmgr doctor versucht, sie zu entschlüsseln, und nennt den Grund, wenn es nicht klappt.');
+        }
         return 0;
     }
     if (kommando === 'log') {
@@ -936,7 +951,7 @@ export async function ausfuehren(argv, umgebung, optionen = {}) {
                 if (ereignis.art === 'checkout')
                     continue;
                 andere = true;
-                console.log(`  ${verlaufEreignisZeile(ereignis)}`);
+                console.log(`  ${verlaufEreignisZeile(ereignis, quellenListe)}`);
                 // Unter einem Versionssprung die Commits der neuen Version(en), eingerückt (E108).
                 if (ereignis.art === 'hmgr-installiert') {
                     const aenderungen = await anwendungsfaelle.hmgrAenderungen(ereignis.vorher, ereignis.version);
@@ -952,7 +967,7 @@ export async function ausfuehren(argv, umgebung, optionen = {}) {
     }
     if (kommando === 'doctor') {
         restPruefen(schalterLesen(argv.slice(1), 'doctor').rest, 0, 'doctor');
-        const { fehlendeArbeitsverzeichnisse, vergessen } = await anwendungsfaelle.doctor();
+        const { fehlendeArbeitsverzeichnisse, vergessen, sops } = await anwendungsfaelle.doctor();
         if (fehlendeArbeitsverzeichnisse.length === 0)
             console.log('Keine fehlenden Arbeitsverzeichnisse.');
         for (const pfad of fehlendeArbeitsverzeichnisse) {
@@ -961,6 +976,10 @@ export async function ausfuehren(argv, umgebung, optionen = {}) {
             else
                 console.log(`  liegen lassen   ${pfad}  (ohne Bestätigung nicht vergessen)`);
         }
+        // SOPS-Dateien (E115): nur bei einem Fund eine Zeile, wer kein SOPS nutzt, sieht nichts davon.
+        const sopsQuellen = sops.length === 0 ? [] : await anwendungsfaelle.quellen();
+        for (const zeile of sopsBerichtZeilen(sops, sopsQuellen))
+            console.log(zeile);
         return 0;
     }
     if (kommando === 'harness') {
@@ -1185,8 +1204,21 @@ function bundleBericht(eintraege) {
 function aenderungsZeilen(aenderungen) {
     return aenderungen.flatMap((a) => [`    ${a.version}`, ...a.commits.map((c) => `      ${c}`)]);
 }
+/** Bericht zu SOPS-Dateien aus doctor und update (E115), Spalten wie die übrigen Berichtszeilen. */
+function sopsBerichtZeilen(befunde, quellen) {
+    return befunde.map((befund) => {
+        const ort = `${befund.datei} aus ${quellenAnzeigeName({ quelle: quelleAlsText(befund.checkout.quelle), ref: befund.checkout.ref }, quellen)}`;
+        if (befund.ergebnis === 'repariert')
+            return `  entschlüsselt   ${ort}`;
+        if (befund.ergebnis === 'verschluesselt')
+            return `  verschlüsselt   ${ort}: ${sopsGrundText(befund.grund)}`;
+        return `  fehlgeschlagen  ${ort}: ${befund.fehler}`;
+    });
+}
 /** Eine Ereigniszeile im Verlauf (E80), eingerückt unter der Kopfzeile ihres Laufs. Checkouts stellt `checkoutGruppen` dar (E109). */
-function verlaufEreignisZeile(ereignis) {
+function verlaufEreignisZeile(ereignis, quellen) {
+    if (ereignis.art === 'sops-verschluesselt' || ereignis.art === 'sops-repariert')
+        return sopsZeile(ereignis, quellen);
     if (ereignis.art === 'bundle') {
         const teile = [
             ereignis.gelegt.length > 0 ? `gelegt ${ereignis.gelegt.join(', ')}` : undefined,

package/dist/cli/verlauf-anzeige.js

@@ -59,3 +59,20 @@ export function verlaufZeitpunkt(iso, jetzt = new Date()) {
         return `Gestern, ${uhr}`;
     return `${zwei(datum.getDate())}.${zwei(datum.getMonth() + 1)}.${datum.getFullYear()}, ${uhr}`;
 }
+/** Warum eine SOPS-Datei verschlüsselt blieb (E115), in Alltagssprache. GUI: renderer.js, sopsGrundText. */
+export function sopsGrundText(grund) {
+    if (grund === 'sops-fehlt')
+        return 'sops ist auf diesem Rechner nicht installiert';
+    if (grund === 'lokale-aenderung')
+        return 'die Datei ist im Checkout von Hand geändert';
+    if (grund === 'wrapper-fehlt')
+        return 'sops-clean.sh fehlt (weder in /usr/local/bin noch in ~/bin)';
+    return 'die Entschlüsselung klappt nicht, vermutlich fehlt der passende Schlüssel';
+}
+/** Verlaufszeile zu einer SOPS-Datei (E115): verschlüsselt geblieben oder nachträglich entschlüsselt. */
+export function sopsZeile(ereignis, quellen) {
+    const ort = `${ereignis.datei} aus ${quellenAnzeigeName(ereignis, quellen)}`;
+    return ereignis.grund === undefined
+        ? `Verschlüsselte Datei ${ort} entschlüsselt`
+        : `Datei ${ort} bleibt verschlüsselt: ${sopsGrundText(ereignis.grund)}`;
+}

package/dist/gui/renderer/renderer.js

@@ -3202,9 +3202,25 @@
     } else if (ereignis.art === 'cli-verfuegbar') {
       li.appendChild(e('span', 'marke-ok', 'verfügbar'));
       li.appendChild(e('span', 'pfad', 'CLI ' + ereignis.version));
+    } else if (ereignis.art === 'sops-verschluesselt') {
+      // E115: Wortlaut wie sopsZeile/sopsGrundText in src/cli/verlauf-anzeige.ts.
+      li.appendChild(e('span', 'marke-aus', 'verschlüsselt'));
+      li.appendChild(e('span', 'pfad', ereignis.datei + ' aus ' + verlaufQuellenName(ereignis.quelle, ereignis.ref)
+        + ' bleibt verschlüsselt: ' + sopsGrundText(ereignis.grund)));
+    } else if (ereignis.art === 'sops-repariert') {
+      li.appendChild(e('span', 'marke-ok', 'entschlüsselt'));
+      li.appendChild(e('span', 'pfad', ereignis.datei + ' aus ' + verlaufQuellenName(ereignis.quelle, ereignis.ref)));
     }
   }
 
+  /** Warum eine SOPS-Datei verschlüsselt blieb (E115), wie sopsGrundText in src/cli/verlauf-anzeige.ts. */
+  function sopsGrundText(grund) {
+    if (grund === 'sops-fehlt') return 'sops ist auf diesem Rechner nicht installiert';
+    if (grund === 'lokale-aenderung') return 'die Datei ist im Checkout von Hand geändert';
+    if (grund === 'wrapper-fehlt') return 'sops-clean.sh fehlt (weder in /usr/local/bin noch in ~/bin)';
+    return 'die Entschlüsselung klappt nicht, vermutlich fehlt der passende Schlüssel';
+  }
+
   /**
    * Anzeigename einer Quelle im Verlauf (E109). Baut quelleVerlaufName (src/kern/modell.ts) nach,
    * der Renderer kann die Kern-Datei nicht importieren: Quelle aus QUELLEN über die Identität

package/dist/kern/anwendungsfaelle.js

@@ -1387,19 +1387,101 @@ export class Anwendungsfaelle {
      * dieselbe Weiche wie bei `verwaisteAufraeumen`.
      */
     async doctor(args) {
-        const rueckfragen = args?.rueckfragen ?? true;
+        const ergebnis = await this.doctorPruefen(args?.rueckfragen ?? true);
+        // Nur die SOPS-Befunde kommen in den Verlauf (E115); fehlende Arbeitsverzeichnisse meldet der
+        // alleinstehende doctor wie bisher nur auf der Konsole.
+        await this.sopsVermerken(args?.ausloeser ?? 'cli', ergebnis.sops, true);
+        return ergebnis;
+    }
+    /**
+     * doctor ohne Verlauf, damit der Aktualisieren-Lauf die Befunde in seinen eigenen Eintrag nimmt.
+     * Dazu die SOPS-Prüfung (E115): Checkouts geführter Quellen, deren SOPS-Datei noch verschlüsselt
+     * im Arbeitsbaum liegt, schreibt der Quellen-Port neu, wo die Probe klappt. Sie ist keine
+     * Rückfrage wert: die Datei entspricht dem Commit, nur entschlüsselt.
+     */
+    async doctorPruefen(rueckfragen) {
         const zustand = await this.p.zustand.lesen();
         const fehlend = [];
         for (const pfad of zustand.arbeitsverzeichnisse)
             if (!(await this.p.zeiger.verzeichnisExistiert(pfad)))
                 fehlend.push(pfad);
-        if (fehlend.length === 0 || !rueckfragen)
-            return { fehlendeArbeitsverzeichnisse: fehlend, vergessen: [] };
-        if (!(await this.p.rueckfrage.bestaetigen(doctorFrage(fehlend))))
-            return { fehlendeArbeitsverzeichnisse: fehlend, vergessen: [] };
-        for (const pfad of fehlend)
-            await this.arbeitsverzeichnisVergessen(pfad);
-        return { fehlendeArbeitsverzeichnisse: fehlend, vergessen: [...fehlend] };
+        let vergessen = [];
+        if (fehlend.length > 0 && rueckfragen && (await this.p.rueckfrage.bestaetigen(doctorFrage(fehlend)))) {
+            for (const pfad of fehlend)
+                await this.arbeitsverzeichnisVergessen(pfad);
+            vergessen = [...fehlend];
+        }
+        const sops = [];
+        for (const checkout of await this.gefuehrteCheckouts(zustand.quellen)) {
+            const reparaturen = await this.p.quellen.sopsReparieren(checkout).catch(() => []);
+            for (const reparatur of reparaturen)
+                sops.push({ checkout, ...reparatur });
+        }
+        return { fehlendeArbeitsverzeichnisse: fehlend, vergessen, sops };
+    }
+    /** Checkouts, deren Quelle der Zustand führt (E54), mit dem Anzeigenamen der geführten Quelle. */
+    async gefuehrteCheckouts(quellen) {
+        const bekannt = new Map(quellen.map((q) => [quelleSchluessel(q), q]));
+        const ergebnis = [];
+        for (const checkout of await this.p.quellen.checkouts()) {
+            const gefuehrt = bekannt.get(quelleSchluessel(checkout.quelle));
+            if (gefuehrt !== undefined)
+                ergebnis.push({ ...checkout, quelle: quelleMitNamen(checkout.quelle, gefuehrt.name) });
+        }
+        return ergebnis;
+    }
+    /**
+     * SOPS-Dateien, die im Arbeitsbaum eines Checkouts noch verschlüsselt liegen (E115), für
+     * `hmgr status`. Liest nur, ruft kein sops auf und repariert nichts.
+     */
+    async sopsVerschluesselteDateien() {
+        const ergebnis = [];
+        for (const checkout of await this.gefuehrteCheckouts((await this.p.zustand.lesen()).quellen)) {
+            const dateien = await this.p.quellen.sopsDateien(checkout).catch(() => []);
+            for (const d of dateien)
+                if (d.verschluesselt)
+                    ergebnis.push({ checkout, datei: d.datei });
+        }
+        return ergebnis;
+    }
+    /**
+     * SOPS-Befunde als Verlaufsereignisse (E115). „Verschlüsselt" und ein gescheitertes Neuschreiben
+     * kommen einmal je Datei und Grund (`gemerkt.sops`), „repariert" jedes Mal, wenn es geschieht.
+     * `vollstaendig`: die Befunde decken alle Checkouts ab, dann ersetzen sie die gemerkte Liste;
+     * sonst (ein einzelner Checkout beim Verlinken) kommen sie dazu.
+     */
+    async sopsEreignisse(befunde, vollstaendig) {
+        const bisher = (await this.p.verlauf.lesen()).gemerkt.sops ?? [];
+        const aktuell = [];
+        const ereignisse = [];
+        for (const befund of befunde) {
+            const quelle = quelleAlsText(befund.checkout.quelle);
+            const { ref } = befund.checkout;
+            if (befund.ergebnis === 'repariert') {
+                ereignisse.push({ art: 'sops-repariert', quelle, ref, datei: befund.datei });
+                continue;
+            }
+            const art = befund.ergebnis === 'verschluesselt' ? befund.grund : 'fehlgeschlagen';
+            const schluessel = `${quelle} @ ${ref}: ${befund.datei} | ${art}`;
+            if (aktuell.includes(schluessel))
+                continue;
+            aktuell.push(schluessel);
+            if (bisher.includes(schluessel))
+                continue;
+            if (befund.ergebnis === 'verschluesselt')
+                ereignisse.push({ art: 'sops-verschluesselt', quelle, ref, datei: befund.datei, grund: befund.grund });
+            else
+                ereignisse.push({
+                    art: 'fehler',
+                    betrifft: `${quelle} @ ${ref}: ${befund.datei}`,
+                    fehler: `verschlüsselte Datei nicht neu geschrieben: ${befund.fehler}`,
+                });
+        }
+        return { ereignisse, gemerkt: vollstaendig ? aktuell : [...new Set([...bisher, ...aktuell])] };
+    }
+    async sopsVermerken(ausloeser, befunde, vollstaendig) {
+        const { ereignisse, gemerkt } = await this.sopsEreignisse(befunde, vollstaendig);
+        await this.verlaufVermerken(ausloeser, ereignisse, gemerkt);
     }
     /**
      * Mehrere composer.json unter einem Verzeichnis (E26): hmgr rät nicht, es fragt. Bleibt die Frage
@@ -1480,7 +1562,11 @@ export class Anwendungsfaelle {
             throw new OrtNichtUnterstuetzt(harness.name, ziel.ort.art);
         const verzeichnis = harness.zielVerzeichnis(ziel.ort);
         // Die Prüfung auf einen fremden Eintrag macht der Ziele-Port unmittelbar vor dem Anlegen (E12).
-        const checkout = await this.p.quellen.checkout(fund.quelle, fund.ref, [fund.skill]);
+        // Nur Quelle, Ref und Pfad gehen in den Link, die SOPS-Befunde nicht.
+        const { sopsVerschluesselt, ...checkout } = await this.p.quellen.checkout(fund.quelle, fund.ref, [fund.skill]);
+        // Verschlüsselt angekommene SOPS-Dateien (E115) gleich melden, nicht erst beim nächsten Lauf.
+        if (sopsVerschluesselt.length > 0)
+            await this.sopsVermerken('aktion', sopsVerschluesselt.map((v) => ({ checkout, datei: v.datei, ergebnis: 'verschluesselt', grund: v.grund })), false);
         await harness.vorbereiten(ziel.ort);
         await this.p.ziele.linkLegen(ziel, verzeichnis, fund.skill.name, checkout, fund.skill, ersetzen);
         return { ziel, name: fund.skill.name, checkout, skill: fund.skill };
@@ -2076,9 +2162,15 @@ export class Anwendungsfaelle {
             ? { verwaiste: [], gefragt: false }
             : await this.verwaisteAufraeumen(checkouts, rueckfragen);
         const doctorErgebnis = nurSchluessel !== undefined
-            ? { fehlendeArbeitsverzeichnisse: [], vergessen: [] }
-            : await this.doctor({ rueckfragen });
-        await this.verlaufVermerken(ausloeser, this.aktualisierungsEreignisse(checkouts, pluginFehler, bundles, aufraeumen, doctorErgebnis));
+            ? { fehlendeArbeitsverzeichnisse: [], vergessen: [], sops: [] }
+            : await this.doctorPruefen(rueckfragen);
+        // Die SOPS-Befunde (E115) kommen in denselben Eintrag; ein eingeschränkter Lauf prüft sie nicht
+        // und lässt die gemerkte Liste stehen.
+        const sops = nurSchluessel !== undefined ? undefined : await this.sopsEreignisse(doctorErgebnis.sops, true);
+        await this.verlaufVermerken(ausloeser, [
+            ...this.aktualisierungsEreignisse(checkouts, pluginFehler, bundles, aufraeumen, doctorErgebnis),
+            ...(sops?.ereignisse ?? []),
+        ], sops?.gemerkt);
         return { checkouts, pluginHarnesses, pluginFehler, bundles, aufraeumen, doctor: doctorErgebnis };
     }
     /**
@@ -2129,13 +2221,23 @@ export class Anwendungsfaelle {
             ereignisse.push({ art: 'arbeitsverzeichnis-vergessen', pfad });
         return ereignisse;
     }
-    /** Neuen Eintrag vorn anfügen, nur wenn Ereignisse da sind (E80). Kappen übernimmt der Adapter. */
-    async verlaufVermerken(ausloeser, ereignisse) {
-        if (ereignisse.length === 0)
-            return;
+    /**
+     * Neuen Eintrag vorn anfügen, nur wenn Ereignisse da sind (E80). Kappen übernimmt der Adapter.
+     * `sopsGemerkt` (E115) ersetzt die gemerkten SOPS-Meldungen; hat sich nur diese Liste geändert,
+     * wird sie ohne neuen Eintrag geschrieben.
+     */
+    async verlaufVermerken(ausloeser, ereignisse, sopsGemerkt) {
         const daten = await this.p.verlauf.lesen();
+        const sopsGeaendert = sopsGemerkt !== undefined && JSON.stringify(sopsGemerkt) !== JSON.stringify(daten.gemerkt.sops ?? []);
+        if (ereignisse.length === 0 && !sopsGeaendert)
+            return;
+        const gemerkt = sopsGeaendert ? { ...daten.gemerkt, sops: sopsGemerkt } : daten.gemerkt;
+        if (ereignisse.length === 0) {
+            await this.p.verlauf.schreiben({ gemerkt, eintraege: daten.eintraege });
+            return;
+        }
         const eintrag = { zeit: new Date().toISOString(), ausloeser, ereignisse };
-        await this.p.verlauf.schreiben({ gemerkt: daten.gemerkt, eintraege: [eintrag, ...daten.eintraege] });
+        await this.p.verlauf.schreiben({ gemerkt, eintraege: [eintrag, ...daten.eintraege] });
     }
     /** Der Verlauf, neueste zuerst (E80). */
     async verlauf() {

package/package.json

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