hmgr 0.0.38 → 0.0.41

package/dist/adapter/aenderungen-json.js

@@ -0,0 +1,31 @@
+// Die Änderungsliste als mitgelieferte JSON-Datei dist/aenderungen.json (E108). Der Adapter liegt in
+// dist/adapter/, die Datei eine Ebene höher; im Quellbaum (node src/cli/main.ts) gibt es sie nicht,
+// dann ist die Liste leer. Fehlende oder kaputte Datei ist nie ein Fehler.
+import { readFile } from 'node:fs/promises';
+import { fileURLToPath } from 'node:url';
+import { ohneBom } from "./datei-text.js";
+export class AenderungenJson {
+    pfad;
+    constructor(pfad = fileURLToPath(new URL('../aenderungen.json', import.meta.url))) {
+        this.pfad = pfad;
+    }
+    async lesen() {
+        const roh = await readFile(this.pfad, 'utf8').catch(() => undefined);
+        if (roh === undefined)
+            return {};
+        try {
+            const daten = JSON.parse(ohneBom(roh));
+            if (typeof daten.versionen !== 'object' || daten.versionen === null || Array.isArray(daten.versionen))
+                return {};
+            const ergebnis = {};
+            for (const [version, commits] of Object.entries(daten.versionen)) {
+                if (Array.isArray(commits))
+                    ergebnis[version] = commits.filter((c) => typeof c === 'string');
+            }
+            return ergebnis;
+        }
+        catch {
+            return {};
+        }
+    }
+}

package/dist/aenderungen.json

@@ -0,0 +1,8 @@
+{
+  "fassung": 1,
+  "versionen": {
+    "0.0.41": [
+      "Im Verlauf steht unter „hmgr … installiert\" jetzt aufklappbar, was sich in der neuen Version geändert hat."
+    ]
+  }
+}

package/dist/cli/hilfe.js

@@ -564,6 +564,10 @@ Fehler zu einer Quelle oder einem Bundle, dazu hmgr-Ereignisse: ein Versionsspru
 (GUI oder CLI, erkannt beim Start bzw. bei jedem CLI-Aufruf) oder ein gefundenes Update, das noch
 nicht installiert ist. Plugins stehen nicht im Verlauf (siehe hmgr help update).
 
+Unter einem „installiert"-Eintrag von hmgr stehen die Änderungen: je Version seit der zuvor
+vermerkten die Nummer und darunter die Änderungen als kurze Sätze (E108). Einträge ohne bekannte Vorversion
+zeigen nur die eigene Version, ohne mitgelieferte Änderungsliste entfällt der Abschnitt.
+
 Der Verlauf ist je Rechner: mehrere Maschinen führen ihre eigene Datei, es gibt kein Zusammenführen.
 
 Schalter: keine.

package/dist/cli/main.js

@@ -22,6 +22,7 @@ import { TerminalRueckfrage } from "../adapter/terminal.js";
 import { ProzessUmgebung } from "../adapter/umgebung.js";
 import { ZustandJson } from "../adapter/zustand-json.js";
 import { VerlaufJson } from "../adapter/verlauf-json.js";
+import { AenderungenJson } from "../adapter/aenderungen-json.js";
 import { HILFE, hilfeText } from "./hilfe.js";
 export function umgebungLesen(env = process.env) {
     const home = env.HOME ?? homedir();
@@ -104,6 +105,7 @@ export function bauen(umgebung, optionen = {}) {
             variablen: async (distro) => await new WslBruecke(distro, wslUmgebungAusfuehren).variablen(),
         },
         verlauf,
+        aenderungen: optionen.aenderungen ?? new AenderungenJson(),
     };
     return { anwendungsfaelle: new Anwendungsfaelle(ports), ports };
 }
@@ -858,8 +860,15 @@ export async function ausfuehren(argv, umgebung, optionen = {}) {
             console.log('Noch keine Ereignisse.');
         for (const eintrag of eintraege) {
             console.log(verlaufZeitpunkt(eintrag.zeit));
-            for (const ereignis of eintrag.ereignisse)
+            for (const ereignis of eintrag.ereignisse) {
                 console.log(`  ${verlaufEreignisZeile(ereignis)}`);
+                // 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);
+                    for (const zeile of aenderungsZeilen(aenderungen))
+                        console.log(zeile);
+                }
+            }
         }
         return 0;
     }
@@ -1091,6 +1100,10 @@ function verlaufZeitpunkt(iso) {
     return (`${zwei(datum.getDate())}.${zwei(datum.getMonth() + 1)}.${datum.getFullYear()} ` +
         `${zwei(datum.getHours())}:${zwei(datum.getMinutes())}`);
 }
+/** Je Version die Nummer und darunter ihre Commit-Betreffs, tiefer eingerückt als die Ereigniszeile (E108). */
+function aenderungsZeilen(aenderungen) {
+    return aenderungen.flatMap((a) => [`    ${a.version}`, ...a.commits.map((c) => `      ${c}`)]);
+}
 /** Eine Ereigniszeile im Verlauf (E80), eingerückt unter der Kopfzeile ihres Laufs. */
 function verlaufEreignisZeile(ereignis) {
     if (ereignis.art === 'checkout') {

package/dist/gui/main.js

@@ -11,6 +11,7 @@ import { randomUUID } from 'node:crypto';
 import { stat } from 'node:fs/promises';
 import { fileURLToPath } from 'node:url';
 import { bauen, umgebungLesen } from "../cli/main.js";
+import { AenderungenJson } from "../adapter/aenderungen-json.js";
 import { quelleAlsText, quelleAusText } from "../adapter/quelle-text.js";
 import { paketVersion } from "../adapter/paket-version.js";
 import { infoPlistPfad, MeldungsPuffer, neuereVersionAufPlatte } from "./selbst-update.js";
@@ -129,6 +130,11 @@ const rueckfrage = new GuiRueckfrage();
 const { anwendungsfaelle, ports } = bauen(umgebung, {
     rueckfrage,
     ...(smoketest ? { claudeAusfuehrer: smoketestClaudeAusfuehrer } : {}),
+    // Nur der Smoke-Test biegt die Änderungsliste auf eine Fixture-Datei um (E108); sonst die
+    // mitgelieferte dist/aenderungen.json.
+    ...(smoketest && process.env.HMGR_GUI_SMOKE_AENDERUNGEN !== undefined
+        ? { aenderungen: new AenderungenJson(process.env.HMGR_GUI_SMOKE_AENDERUNGEN) }
+        : {}),
 });
 /**
  * Wer den laufenden Aktualisieren-Lauf ausgelöst hat (E80): der Renderer reicht es bei jedem Aufruf
@@ -329,6 +335,8 @@ function registriereIpc() {
     }));
     // Changelog der letzten Läufe (E80), neueste zuerst.
     ipcMain.handle('hmgr:verlauf', async () => auffangen(async () => anwendungsfaelle.verlauf()));
+    // Änderungen (Commit-Betreffs) der Versionen eines hmgr-Versionssprungs (E108).
+    ipcMain.handle('hmgr:hmgrAenderungen', async (_event, vorher, version) => auffangen(async () => anwendungsfaelle.hmgrAenderungen(vorher, version)));
     // E77: der Prüfen-Knopf stößt zusätzlich zum Quellen-Lauf die Prüfung auf hmgr selbst an. Kein
     // `handle`, sondern `send`/`on`: der Renderer wartet auf nichts, das Ergebnis kommt später von
     // sich aus über 'hmgr:selbstUpdate'.
@@ -416,8 +424,11 @@ function registriereIpc() {
     }));
     // MCP-Ansicht (E61-Folgerunde): Whitelisting und der F39-Vermerk je Karte stehen in mcp-ansicht.ts
     // (rein, ohne Electron, wie oeffnen.ts und icons.ts), damit sie testbar sind. Der Main-Prozess
-    // ruft nur noch auf und liefert die eigene Prozess-Umgebung für die F39-Prüfung.
-    ipcMain.handle('hmgr:mcpUebersicht', async () => auffangen(async () => mcpUebersichtSerialisieren(await anwendungsfaelle.mcpUebersicht(), process.env)));
+    // ruft nur noch auf; die F39-Lage je Welt (lokal, WSL-Distro) kommt aus dem Kern (E107).
+    ipcMain.handle('hmgr:mcpUebersicht', async () => auffangen(async () => {
+        const uebersicht = await anwendungsfaelle.mcpUebersicht();
+        return mcpUebersichtSerialisieren(uebersicht, await anwendungsfaelle.mcpVariablenLage(uebersicht));
+    }));
     // Plätze für den Einhängen-Dialog (F42): die Fähigkeit hängt am Adapter, nicht am Namen (E16),
     // deshalb kommt die Liste unverändert aus dem Kern statt aus einer Harness-Fallunterscheidung hier.
     ipcMain.handle('hmgr:mcpPlaetze', async () => auffangen(async () => anwendungsfaelle.mcpPlaetze()));
@@ -709,6 +720,23 @@ function fensterOeffnen() {
                 verlaufBloecke = document.querySelectorAll('#verlauf .block').length;
                 if (verlaufBloecke > 0) break;
               }
+              // E108: die Änderungslisten kommen nach dem Verlauf per IPC; warten, bis jeder Platz
+              // entweder sein details hat oder (ohne Daten) entfernt ist.
+              for (var wartezeit2 = 0; wartezeit2 < 2000; wartezeit2 += 100) {
+                if (document.querySelector('#verlauf .aenderungen-platz:empty') === null) break;
+                await new Promise((r) => setTimeout(r, 100));
+              }
+              var aenderungenDetails = document.querySelectorAll('#verlauf details.aenderungen').length;
+              var aenderungenElement = document.querySelector('#verlauf details.aenderungen');
+              var aenderungenSummary = aenderungenElement?.querySelector('summary')?.textContent?.trim() ?? null;
+              var aenderungenOffenVorher = aenderungenElement?.open ?? null;
+              aenderungenElement?.querySelector('summary')?.click();
+              var aenderungenOffenNachher = aenderungenElement?.open ?? null;
+              var aenderungenGruppen = aenderungenElement?.querySelectorAll('.aenderungen-version').length ?? 0;
+              var aenderungenText = Array.prototype.map.call(
+                aenderungenElement?.querySelectorAll('.aenderungen-version') ?? [],
+                (g) => g.textContent.replace(/\\s+/g, ' ').trim(),
+              ).join(' ');
               var verlaufText = document.getElementById('verlauf')?.textContent?.replace(/\\s+/g, ' ').trim() ?? null;
               // Nachziehen je Quelle (E89): das Fixture hat im skills-repo einen neuen Upstream-Commit
               // (fixtureAufbauen), den erst ein Lauf für diese Quelle holt. Erst der Knopf der
@@ -1292,6 +1320,12 @@ function fensterOeffnen() {
                 verlaufVorhanden,
                 verlaufText,
                 verlaufBloecke,
+                aenderungenDetails,
+                aenderungenSummary,
+                aenderungenOffenVorher,
+                aenderungenOffenNachher,
+                aenderungenGruppen,
+                aenderungenText,
                 nachziehenFehler,
                 nachziehenKnopfZahl,
                 nachziehenBloeckeStart,

package/dist/gui/mcp-ansicht.js

@@ -1,7 +1,7 @@
 // MCP-Ansicht der GUI (E61-Folgerunde): reine Umformung von Kern-Daten in IPC-taugliche, gewhiteliste
 // Objekte, ohne Electron — testbar wie oeffnen.ts und icons.ts. Der eigentliche IPC-Handler in
 // main.ts ruft diese Funktionen nur noch auf.
-import { variablenVerweise, } from "../kern/anwendungsfaelle.js";
+import {} from "../kern/anwendungsfaelle.js";
 /** Katalog-Eintrag über IPC: die bekannten Felder, nichts ungefiltert durchgereicht (E40 R3). */
 export function mcpEintragSerialisieren(eintrag) {
     return {
@@ -12,23 +12,14 @@ export function mcpEintragSerialisieren(eintrag) {
         konfig: eintrag.konfig,
     };
 }
-/**
- * F39 an der Katalog-Karte: dieselbe Prüf-Funktion wie beim tatsächlichen Einhängen
- * (`variablenVerweise`), hier aber nur gegen die übergebene Umgebung geprüft — ohne den
- * ortsbezogenen `.env`-Abgleich, der ist ortsspezifisch und bleibt dem eigentlichen Einhängen
- * vorbehalten (kommt von dort als `warnung` zurück).
- */
-export function mcpFehlendeVariablen(eintrag, umgebung) {
-    return variablenVerweise(eintrag.konfig).filter((name) => !(name in umgebung) || umgebung[name] === undefined);
-}
-/** Übersicht über IPC (E61-Folgerunde): Katalog-Einträge whitelisted, dazu der F39-Vermerk je Karte. */
-export function mcpUebersichtSerialisieren(uebersicht, umgebung) {
+/** Übersicht über IPC (E61-Folgerunde): Katalog-Einträge whitelisted, dazu je Karte die F39-Befunde je Welt (E107, `variablenWelten`). */
+export function mcpUebersichtSerialisieren(uebersicht, lage) {
     return {
         katalog: uebersicht.katalog.map((k) => ({
             eintrag: mcpEintragSerialisieren(k.eintrag),
             eingehaengt: k.eingehaengt,
             geteilteFundorte: k.geteilteFundorte,
-            fehlendeVariablen: mcpFehlendeVariablen(k.eintrag, umgebung),
+            variablenWelten: lage.get(k.eintrag.name) ?? [],
         })),
         unbekannt: uebersicht.unbekannt,
         unbekannteGeteilteFundorte: uebersicht.unbekannteGeteilteFundorte,

package/dist/gui/preload.cjs

@@ -35,6 +35,8 @@ contextBridge.exposeInMainWorld('hmgr', {
     aktualisieren: (args) => ipcRenderer.invoke('hmgr:aktualisieren', args),
     /** Changelog der letzten Läufe (E80), neueste zuerst. */
     verlauf: () => ipcRenderer.invoke('hmgr:verlauf'),
+    /** Commit-Betreffs der Versionen zwischen `vorher` (exklusiv) und `version` (E108), neueste zuerst. */
+    hmgrAenderungen: (vorher, version) => ipcRenderer.invoke('hmgr:hmgrAenderungen', vorher, version),
     /** Installiert das geladene GUI-Update und startet neu (E80), Gegenstück zum Neustart-Knopf. */
     neuStarten: () => {
         ipcRenderer.send('hmgr:neuStarten');

package/dist/gui/renderer/renderer.js

@@ -323,7 +323,7 @@
   // Homedirs je Harness (E78): je Eintrag { harness, heime: [{ adresse?, pfad, eingestellt }],
   // kannZusaetzliche }. Grundlage der Homedir-Zeilen in den Einstellungen.
   var HARNESS_HEIME = [];
-  // MCP-Katalog (E61-Folgerunde): je Eintrag { eintrag, eingehaengt, fehlendeVariablen }, dazu
+  // MCP-Katalog (E61-Folgerunde): je Eintrag { eintrag, eingehaengt, variablenWelten }, dazu
   // Einträge in Harness-Konfigurationen, die nicht im Katalog stehen (nur genannt). Seit F46 nur
   // noch Grundlage für den MCP-Abschnitt der Ziel-Karten (mcpZeilenFuerZiel), die MCP-Ansicht selbst
   // zeigt keine Fundorte mehr.
@@ -2927,6 +2927,12 @@
     } else if (ereignis.art === 'hmgr-installiert') {
       li.appendChild(e('span', 'marke-ok', 'installiert'));
       li.appendChild(e('span', 'pfad', (ereignis.paket === 'gui' ? 'hmgr-GUI ' : 'hmgr ') + ereignis.version));
+      // E108: die Commits der Versionen seit der zuvor installierten, zum Ausklappen unter der Zeile.
+      // Der Platzhalter hält die Stelle, das details kommt nach dem Aufbau des Verlaufs hinein.
+      var aenderungenPlatz = e('div', 'aenderungen-platz');
+      aenderungenPlatz.dataset.vorher = ereignis.vorher || '';
+      aenderungenPlatz.dataset.version = ereignis.version;
+      li.appendChild(aenderungenPlatz);
     } else if (ereignis.art === 'gui-update-geladen') {
       li.appendChild(e('span', 'marke-ok', 'geladen'));
       li.appendChild(e('span', 'pfad', 'GUI-Update ' + ereignis.version));
@@ -2965,6 +2971,29 @@
       block.appendChild(ul);
       box.appendChild(block);
     });
+    // E108: die Änderungslisten nachladen, nachdem der Verlauf steht. Ein Fehler lässt nur den
+    // jeweiligen Abschnitt weg, nie den Verlauf.
+    var plaetze = Array.prototype.slice.call(box.querySelectorAll('.aenderungen-platz'));
+    await Promise.all(plaetze.map(async function (platz) {
+      var versionen = await window.hmgr.hmgrAenderungen(platz.dataset.vorher || undefined, platz.dataset.version)
+        .then(function (r) { return r && r.ok ? r.daten : []; }, function () { return []; });
+      if (versionen.length === 0) { platz.remove(); return; }
+      var zahl = versionen.reduce(function (summe, v) { return summe + v.commits.length; }, 0);
+      var d = e('details', 'notizen aenderungen');
+      var s = e('summary');
+      s.appendChild(keilIcon());
+      s.appendChild(document.createTextNode('Änderungen (' + zahl + ')'));
+      d.appendChild(s);
+      versionen.forEach(function (v) {
+        var gruppe = e('div', 'aenderungen-version');
+        gruppe.appendChild(e('b', null, v.version));
+        var liste = e('ul');
+        v.commits.forEach(function (commit) { liste.appendChild(e('li', null, commit)); });
+        gruppe.appendChild(liste);
+        d.appendChild(gruppe);
+      });
+      platz.appendChild(d);
+    }));
   }
 
   /* ================= PLUGINS ================= */
@@ -3071,13 +3100,11 @@
     return a;
   }
 
-  /** F39: die Prüf-Funktion ist dieselbe wie beim tatsächlichen Einhängen, hier aber nur gegen die
-      Prozess-Umgebung von hmgr (der Main-Prozess liefert `fehlendeVariablen` schon fertig mit der
-      Übersicht, ohne den ortsbezogenen .env-Abgleich, der bleibt dem Einhängen selbst vorbehalten
-      und kommt dann als `warnung` zurück). Wiederverwendet die bestehende .ruhezeile-Optik. */
-  function mcpWarnZeile(fehlend) {
-    var mehrzahl = fehlend.length > 1;
-    var namen = fehlend.map(function (v) { return '${' + v + '}'; }).join(', ');
+  /** F39 (E107): der Main-Prozess liefert je Karte `variablenWelten`, die Befunde je Welt (lokal oder
+      WSL-Distro), geprüft gegen dieselbe Umgebungsquelle wie das Einhängen — ohne den ortsbezogenen
+      .env-Abgleich, der bleibt dem Einhängen selbst vorbehalten und kommt dann als `warnung` zurück.
+      Je Welt mit Befund eine Zeile, Welten ohne Befund keine. Wiederverwendet die .ruhezeile-Optik. */
+  function mcpWarnZeile(text) {
     var rz = e('div', 'ruhezeile');
     var svg = document.createElementNS('http://www.w3.org/2000/svg', 'svg');
     svg.setAttribute('viewBox', '0 0 16 16');
@@ -3085,19 +3112,37 @@
     svg.setAttribute('aria-hidden', 'true');
     svg.innerHTML = '<circle cx="8" cy="8" r="6.5"/><path d="M8 4.5v4M8 10.5v.5"/>';
     rz.appendChild(svg);
-    rz.appendChild(e('p', null, namen + (mehrzahl ? ' sind' : ' ist') + ' in der Umgebung von hmgr nicht gesetzt. Ob '
-      + (mehrzahl ? 'die Variablen' : 'die Variable') + ' beim Start des Harness gesetzt ' + (mehrzahl ? 'sind' : 'ist')
-      + ', kann hmgr nicht wissen.'));
+    rz.appendChild(e('p', null, text));
     return rz;
   }
 
-  /** Notizen sind das Langsame am Eintrag (entwurf/gui.html): zugeklappt, öffnen sich nur, wenn
-      jemand sie sucht. Der Wortlaut bleibt, wie er in der mcp.yaml steht, Zeilenumbrüche
-      eingeschlossen (weiss-raum: pre-line in styles.css). */
-  function mcpNotizenBlock(text) {
-    var d = document.createElement('details');
-    d.className = 'notizen';
-    var s = document.createElement('summary');
+  function mcpWarnZeilen(welten) {
+    var mehrere = welten.some(function (w) { return w.distro !== undefined; });
+    var zeilen = [];
+    welten.forEach(function (w) {
+      if (w.ungeprueft) {
+        zeilen.push(mcpWarnZeile('hmgr konnte die Umgebung von WSL ' + w.distro + ' nicht lesen, die Verweise sind ungeprüft.'));
+        return;
+      }
+      if (w.fehlend.length === 0) return;
+      var mz = w.fehlend.length > 1;
+      var namen = w.fehlend.map(function (v) { return '${' + v + '}'; }).join(', ');
+      var verb = mz ? ' sind' : ' ist';
+      if (w.distro !== undefined) {
+        zeilen.push(mcpWarnZeile(namen + verb + ' in WSL ' + w.distro + ' nicht gesetzt (Login-Shell, interaktiv).'));
+      } else if (mehrere) {
+        zeilen.push(mcpWarnZeile(namen + verb + ' in Windows nicht gesetzt.'));
+      } else {
+        zeilen.push(mcpWarnZeile(namen + verb + ' in der Umgebung von hmgr nicht gesetzt. Ob '
+          + (mz ? 'die Variablen' : 'die Variable') + ' beim Start des Harness gesetzt ' + (mz ? 'sind' : 'ist')
+          + ', kann hmgr nicht wissen.'));
+      }
+    });
+    return zeilen;
+  }
+
+  /** Der Aufklapp-Keil in einer summary (dreht sich per CSS beim Öffnen). */
+  function keilIcon() {
     var pfeil = document.createElementNS('http://www.w3.org/2000/svg', 'svg');
     pfeil.setAttribute('viewBox', '0 0 16 16');
     pfeil.setAttribute('class', 'keil');
@@ -3107,7 +3152,17 @@
     pfeil.setAttribute('stroke-linejoin', 'round');
     pfeil.setAttribute('aria-hidden', 'true');
     pfeil.innerHTML = '<path d="M4.3 2.5 7.8 6 4.3 9.5"/>';
-    s.appendChild(pfeil);
+    return pfeil;
+  }
+
+  /** Notizen sind das Langsame am Eintrag (entwurf/gui.html): zugeklappt, öffnen sich nur, wenn
+      jemand sie sucht. Der Wortlaut bleibt, wie er in der mcp.yaml steht, Zeilenumbrüche
+      eingeschlossen (weiss-raum: pre-line in styles.css). */
+  function mcpNotizenBlock(text) {
+    var d = document.createElement('details');
+    d.className = 'notizen';
+    var s = document.createElement('summary');
+    s.appendChild(keilIcon());
     s.appendChild(document.createTextNode('Notizen'));
     d.appendChild(s);
     d.appendChild(e('p', null, text));
@@ -3135,7 +3190,7 @@
     konf.appendChild(e('span', 'mono', mcpKonfigWortlaut(eintrag.konfig)));
     kEl.appendChild(konf);
 
-    if (k.fehlendeVariablen.length > 0) kEl.appendChild(mcpWarnZeile(k.fehlendeVariablen));
+    mcpWarnZeilen(k.variablenWelten).forEach(function (z) { kEl.appendChild(z); });
     if (eintrag.notizen) kEl.appendChild(mcpNotizenBlock(eintrag.notizen));
 
     return kEl;

package/dist/gui/renderer/styles.css

@@ -490,6 +490,13 @@ img.hsymbol{border-radius:3px}
 .block .marke-ok{color:var(--emaille-hoch);font-weight:700}
 .block .marke-aus{color:var(--messing-tief);font-weight:700}
 .block .pfad{color:var(--tinte-weich)}
+/* E108: Änderungen unter „hmgr X installiert", aufklappbar wie die Notizen der MCP-Karte. */
+.block .aenderungen-platz{grid-column:1 / -1}
+.block .aenderungen-platz:empty{display:none}
+.aenderungen{margin-top:0}
+.aenderungen .aenderungen-version{margin-top:9px;padding-left:13px;border-left:2px solid var(--strich);font-size:16px;color:var(--tinte-weich)}
+.block .aenderungen ul{margin-top:4px;gap:4px;font-size:16px}
+.block .aenderungen li{display:block}
 
 .markt{margin-bottom:26px}
 .marktkopf{display:flex;flex-wrap:wrap;gap:8px 16px;align-items:baseline;margin-bottom:12px;padding-bottom:10px;border-bottom:2px solid var(--tinte)}

package/dist/kern/anwendungsfaelle.js

@@ -6,6 +6,17 @@ import { passenderRef } from "./version.js";
 import { kannIstRegistriert, kannMcp, kannPlugins, kannProfile, kannSkillOrdner, kannZurueckbauen, kannZusaetzlicheHeime, } from "../ports/harness.js";
 /** So viele `plugin list`-Prozesse laufen im Ist-Zustand höchstens gleichzeitig (E93). */
 const PLUGIN_ABFRAGEN_GLEICHZEITIG = 6;
+/** „0.0.39" → [0, 0, 39]; alles andere (Vorabversion, Text) → undefined. */
+function versionZerlegen(version) {
+    const t = /^(\d+)\.(\d+)\.(\d+)$/.exec(version);
+    return t === null ? undefined : [Number(t[1]), Number(t[2]), Number(t[3])];
+}
+function versionVergleichen(a, b) {
+    for (let i = 0; i < 3; i++)
+        if (a[i] !== b[i])
+            return a[i] - b[i];
+    return 0;
+}
 /**
  * Die Welt eines Orts als Text für Bericht und Verlauf (E101), in der Schreibweise von `--ort`:
  * „home" für die Installation dieses Rechners, „wsl:<distro>" für die einer Distro.
@@ -394,6 +405,67 @@ export class Anwendungsfaelle {
             throw new McpUnbekannt(mcpName);
         return eintrag;
     }
+    /**
+     * Die Umgebung einer Welt (E107): ohne `distro` die Prozess-Umgebung, sonst die einer im Terminal
+     * der Distro gestarteten claude (E104). `undefined`, wenn die Distro-Umgebung nicht lesbar ist.
+     * Einzige Stelle dafür, geteilt von Einhängen-Warnung und Kartenhinweis.
+     */
+    async mcpUmgebungDerWelt(distro) {
+        if (distro === undefined)
+            return this.p.umgebung.variablen();
+        return await this.p.wsl.variablen(distro).catch(() => undefined);
+    }
+    /**
+     * F39 an der Katalog-Karte (E107): je Eintrag mit `${VAR}`-Verweisen die Welten, gegen die zu
+     * prüfen ist, jeweils mit Befund. Welten: die der Ziele, an denen der Eintrag eingehängt ist; sonst
+     * die der Ziele, an denen er einhängbar wäre (`ortBedienbar`, ohne Git-Wurzel-Ermittlung). Je Distro
+     * höchstens ein Aufruf je Lauf; ohne Verweise im Katalog wird nichts befragt. Die `.env`-Zusatzdatei
+     * (Hermes) bleibt dem Einhängen vorbehalten. Einträge ohne Verweise fehlen in der Map.
+     */
+    async mcpVariablenLage(uebersicht) {
+        const ergebnis = new Map();
+        const ue = uebersicht ?? (await this.mcpUebersicht());
+        const mitVerweisen = ue.katalog.filter((k) => variablenVerweise(k.eintrag.konfig).length > 0);
+        if (mitVerweisen.length === 0)
+            return ergebnis;
+        let moegliche;
+        const umgebungen = new Map();
+        for (const k of mitVerweisen) {
+            let welten = k.eingehaengt.map((z) => wslDistroVonOrt(z.ort));
+            if (welten.length === 0) {
+                if (moegliche === undefined) {
+                    moegliche = [];
+                    for (const ziel of await this.mcpZiele()) {
+                        const mcp = this.harnessMitMcp(ziel.harness).mcp;
+                        if (mcp.ortBedienbar !== undefined && !(await mcp.ortBedienbar(ziel.ort)))
+                            continue;
+                        moegliche.push(wslDistroVonOrt(ziel.ort));
+                    }
+                }
+                welten = moegliche;
+            }
+            const verweise = variablenVerweise(k.eintrag.konfig);
+            const befunde = [];
+            // Lokale Welt zuerst, dann die Distros in der Reihenfolge ihres Auftretens.
+            const eindeutig = [...new Set(welten)].sort((a, b) => (a === undefined ? -1 : b === undefined ? 1 : 0));
+            for (const distro of eindeutig) {
+                let env = umgebungen.get(distro);
+                if (env === undefined) {
+                    env = this.mcpUmgebungDerWelt(distro);
+                    umgebungen.set(distro, env);
+                }
+                const umgebung = await env;
+                if (umgebung === undefined)
+                    befunde.push({ distro: distro, ungeprueft: true });
+                else {
+                    const fehlend = verweise.filter((v) => umgebung[v] === undefined);
+                    befunde.push(distro === undefined ? { fehlend } : { distro, fehlend });
+                }
+            }
+            ergebnis.set(k.eintrag.name, befunde);
+        }
+        return ergebnis;
+    }
     /**
      * F39: fehlende `${VAR}`-Verweise als Warnung, nie als Abbruch. Geprüft wird gegen die eigene
      * Prozess-Umgebung und, wenn die Fähigkeit eine `.env`-Datei nennt (Hermes), zusätzlich gegen sie.
@@ -404,17 +476,10 @@ export class Anwendungsfaelle {
             return undefined;
         // Ein WSL-Ziel startet claude in der Distro mit deren Umgebung, nicht mit der von Windows (E104).
         const distro = wslDistroVonOrt(ort);
-        let prozessEnv;
-        if (distro === undefined) {
-            prozessEnv = this.p.umgebung.variablen();
-        }
-        else {
-            const distroEnv = await this.p.wsl.variablen(distro).catch(() => undefined);
-            if (distroEnv === undefined) {
-                return (`hmgr konnte die Umgebung der WSL-Distro ${distro} nicht lesen; die Verweise ` +
-                    `${verweise.map((v) => '${' + v + '}').join(', ')} sind deshalb ungeprüft.`);
-            }
-            prozessEnv = distroEnv;
+        const prozessEnv = await this.mcpUmgebungDerWelt(distro);
+        if (prozessEnv === undefined) {
+            return (`hmgr konnte die Umgebung der WSL-Distro ${distro} nicht lesen; die Verweise ` +
+                `${verweise.map((v) => '${' + v + '}').join(', ')} sind deshalb ungeprüft.`);
         }
         const envPfad = faehig.mcp.envDatei?.(ort);
         const zusatzEnv = envPfad === undefined ? {} : await this.p.umgebung.envDatei(envPfad);
@@ -1988,6 +2053,31 @@ export class Anwendungsfaelle {
     async verlauf() {
         return (await this.p.verlauf.lesen()).eintraege;
     }
+    /**
+     * Die Änderungen (Commit-Betreffs) der Versionen, die ein Sprung von `vorher` auf `version`
+     * mitbrachte (E108): alle Versionen V mit vorher < V ≤ version, neueste zuerst. Ohne `vorher`
+     * nur `version` selbst. Versionen ohne Eintrag in der Liste (oder ohne Commits) fehlen im
+     * Ergebnis; eine nicht als x.y.z lesbare Version ergibt eine leere Liste.
+     */
+    async hmgrAenderungen(vorher, version) {
+        const bis = versionZerlegen(version);
+        if (bis === undefined)
+            return [];
+        const ab = vorher === undefined ? undefined : versionZerlegen(vorher);
+        const liste = await this.p.aenderungen.lesen();
+        const treffer = [];
+        for (const [v, commits] of Object.entries(liste)) {
+            const zahlen = versionZerlegen(v);
+            if (zahlen === undefined || commits.length === 0)
+                continue;
+            const imBereich = vorher === undefined
+                ? versionVergleichen(zahlen, bis) === 0
+                : ab !== undefined && versionVergleichen(zahlen, ab) > 0 && versionVergleichen(zahlen, bis) <= 0;
+            if (imBereich)
+                treffer.push({ zahlen, eintrag: { version: v, commits } });
+        }
+        return treffer.sort((a, b) => versionVergleichen(b.zahlen, a.zahlen)).map((t) => t.eintrag);
+    }
     /**
      * Merkt die installierte Version eines hmgr-Pakets (GUI oder CLI) und schreibt bei einem
      * Versionssprung einen Verlaufseintrag (E80). Der erste Aufruf ohne gemerkte Version merkt nur,
@@ -2006,7 +2096,7 @@ export class Anwendungsfaelle {
         const eintrag = {
             zeit: new Date().toISOString(),
             ausloeser,
-            ereignisse: [{ art: 'hmgr-installiert', paket, version }],
+            ereignisse: [{ art: 'hmgr-installiert', paket, version, vorher: bisher }],
         };
         await this.p.verlauf.schreiben({ gemerkt, eintraege: [eintrag, ...daten.eintraege] });
     }

package/dist/ports/aenderungen.js

@@ -0,0 +1,3 @@
+// Änderungen: die gepflegten Sätze je hmgr-Version (E108) aus AENDERUNGEN.md, beim Bauen nach
+// dist/aenderungen.json übertragen (scripts/aenderungen-erzeugen.mjs). Der Verlauf zeigt sie unter „hmgr X installiert".
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hmgr",
-  "version": "0.0.38",
+  "version": "0.0.41",
   "description": "Harness Manager: Skills und Plugins für AI-Harnesses verwalten",
   "license": "MIT",
   "author": "Tim Kaufmann",
@@ -19,7 +19,7 @@
   },
   "scripts": {
     "dev": "node src/cli/main.ts",
-    "build": "tsc -p tsconfig.build.json && node scripts/copy-gui-assets.mjs",
+    "build": "tsc -p tsconfig.build.json && node scripts/copy-gui-assets.mjs && node scripts/aenderungen-erzeugen.mjs",
     "gui": "npm run build && electron dist/gui/main.js",
     "gui:smoke": "npm run build && node scripts/gui-smoke-test.ts",
     "gui:app": "npm run build && electron-builder --mac --arm64",