hmgr 0.0.19 → 0.0.21

package/dist/cli/hilfe.js

@@ -31,7 +31,7 @@ hmgr <kommando> [schalter]
   mcp migrate <name>        MCP-Server aus der geteilten .mcp.json in den privaten Scope übernehmen
   mcp list                  Katalog-Einträge zeigen, mit wo sie eingehängt sind
   sync [pfad]               Ziel auf den Stand seines Zeigers bringen
-  update                    Alle Checkouts aktualisieren
+  update                    Alle Checkouts aktualisieren, mit <skill> oder --quelle nur eine Quelle
   status                    Ist-Zustand der Ziele
   log                       Verlauf der letzten Läufe (Changelog)
   doctor                    Fehlende Arbeitsverzeichnisse finden und Vergessen anbieten
@@ -446,6 +446,8 @@ Häufige Fälle:
 
 Siehe auch: hmgr help dir, hmgr help link, hmgr help update, hmgr help harness`;
 const UPDATE = `hmgr update
+hmgr update <skill>
+hmgr update --quelle <teilstring>
 
 Holt für jeden Checkout unter ~/.hmgr den neuesten Stand seines Refs und zieht bei Harnesses mit
 Plugin-Fähigkeit deren Plugins nach (E14). Die Links zeigen weiter auf dieselben Pfade und müssen
@@ -484,10 +486,21 @@ aufgeräumter Checkout, ein Fehler), schreibt update denselben Eintrag auch in ~
 nicht im Verlauf: „claude plugin marketplace update" liefert keine Auskunft, ob sich etwas geändert
 hat, eine Zeile dazu wäre geschönt.
 
-Schalter: keine.
+Eingeschränkter Lauf (E89): hmgr update <skill> zieht nur die Quelle nach, in der der Skill liegt
+(liegt der Skill in mehreren Quellen, bricht update ab, dann --quelle nutzen). hmgr update --quelle <teilstring> nimmt ein Stück
+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
+übrigen Quellen und Bundles. Der Verlaufseintrag entsteht wie im vollen Lauf.
+
+Schalter:
+  --quelle <teilstring>   Nur diese Quelle nachziehen (statt <skill>)
 
 Beispiel:
   hmgr update
+  hmgr update mein-skill
+  hmgr update --quelle mein-repo
 
 Häufige Fälle:
   „übersprungen … lokale Änderung (E15)": im Checkout liegt eine Änderung, die durch einen Link

package/dist/cli/main.js

@@ -93,7 +93,7 @@ const SCHALTER = {
     bundle: { werte: ['harness', 'ort', 'composer', 'quelle'], flaggen: [] },
     mcp: { werte: ['harness', 'ort'], flaggen: [] },
     sync: { werte: [], flaggen: [] },
-    update: { werte: [], flaggen: [] },
+    update: { werte: ['quelle'], flaggen: [] },
     status: { werte: [], flaggen: [] },
     log: { werte: [], flaggen: [] },
     doctor: { werte: [], flaggen: [] },
@@ -715,8 +715,20 @@ export async function ausfuehren(argv, umgebung, optionen = {}) {
         return 0;
     }
     if (kommando === 'update') {
-        restPruefen(schalterLesen(argv.slice(1), 'update').rest, 0, 'update');
-        const { checkouts: liste, bundles, aufraeumen, doctor, } = await anwendungsfaelle.aktualisieren({ ausloeser: 'cli' });
+        const { rest: updateRest, werte: updateWerte } = schalterLesen(argv.slice(1), 'update');
+        restPruefen(updateRest, 1, 'update');
+        const updateSkill = updateRest[0];
+        const updateHinweis = updateWerte.get('quelle');
+        if (updateSkill !== undefined && updateHinweis !== undefined)
+            throw new Error('update nimmt entweder einen Skill oder --quelle, nicht beides. hmgr help update zeigt die Verwendung.');
+        // Eingeschränkter Lauf (E89): nur die Quelle des Skills bzw. die genannte, ohne Plugins,
+        // Aufräumen und doctor.
+        const nurQuelle = updateSkill !== undefined
+            ? (await anwendungsfaelle.skillFinden(updateSkill)).quelle
+            : updateHinweis !== undefined
+                ? await anwendungsfaelle.quelleZuHinweis(updateHinweis)
+                : undefined;
+        const { checkouts: liste, bundles, aufraeumen, doctor, } = await anwendungsfaelle.aktualisieren({ ausloeser: 'cli', ...(nurQuelle === undefined ? {} : { quelle: nurQuelle }) });
         if (liste.length === 0)
             console.log('Keine Checkouts.');
         for (const { checkout, aktualisierung, geaenderteSkills } of liste) {

package/dist/gui/main.js

@@ -13,6 +13,7 @@ import { fileURLToPath } from 'node:url';
 import { bauen, umgebungLesen } from "../cli/main.js";
 import { quelleAlsText, quelleAusText } from "../adapter/quelle-text.js";
 import { paketVersion } from "../adapter/paket-version.js";
+import { infoPlistPfad, neuereVersionAufPlatte } from "./selbst-update.js";
 import { quelleName, quelleSchluessel } from "../kern/modell.js";
 import { kannProfile } from "../ports/harness.js";
 import { iconFuerQuelle } from "./icons.js";
@@ -331,10 +332,18 @@ function registriereIpc() {
     // Neustart-Knopf an der GUI-Update-Zeile (E80): installiert das geladene Paket sofort, statt auf
     // das nächste Beenden zu warten. Im Smoke-Test ein No-op — dort läuft `updatePruefen` ohnehin nie,
     // der Knopf bleibt verborgen, aber ein Absturz durch ein fehlendes Update darf trotzdem nie sein.
+    // E90: mit einem geladenen Windows-Paket `quitAndInstall`, sonst (macOS: das Bundle liegt schon
+    // ersetzt auf der Platte) ein Neustart des Prozesses. Entscheidend ist das Merker-Flag, nicht die
+    // Plattform allein.
     ipcMain.on('hmgr:neuStarten', () => {
         if (smoketest)
             return;
-        autoUpdater.quitAndInstall();
+        if (geladenesPaketVorhanden) {
+            autoUpdater.quitAndInstall();
+            return;
+        }
+        app.relaunch();
+        app.exit(0);
     });
     ipcMain.handle('hmgr:arbeitsverzeichnisHinzufuegen', async (_event, pfad) => auffangen(async () => anwendungsfaelle.arbeitsverzeichnisHinzufuegen(pfad)));
     ipcMain.handle('hmgr:arbeitsverzeichnisVergessen', async (_event, pfad) => auffangen(async () => anwendungsfaelle.arbeitsverzeichnisVergessen(pfad)));
@@ -500,6 +509,7 @@ function fensterOeffnen() {
     });
     hauptfenster.on('closed', () => {
         hauptfenster = null;
+        zuletztGemeldeteGuiVersion = null;
     });
     // Der <title> der index.html setzt den Fenstertitel beim Laden sonst zurück und überschriebe die
     // Option oben (E72). Der DOM-Titel bleibt dabei, wie er ist, nur das Fenster folgt ihm nicht mehr.
@@ -676,6 +686,34 @@ function fensterOeffnen() {
                 if (verlaufBloecke > 0) break;
               }
               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
+              // anderen Quelle (kaputt-repo, ohne Checkout): der Verlauf bleibt, wie er ist, obwohl
+              // das skills-repo hinterherhinkt. Dann der Knopf des skills-repo: ein neuer Block, der
+              // nur diese Quelle nennt.
+              var nachziehenFehler = null;
+              var nachziehenKnopfZahl = document.querySelectorAll('#quellenliste .nachziehen').length;
+              var nachziehenBloeckeStart = document.querySelectorAll('#verlauf .block').length;
+              var nachziehenBloeckeNachAnderer = -1;
+              var nachziehenBloeckeNachEigener = -1;
+              var nachziehenErsterBlock = null;
+              try {
+                var nachziehenLauf = async (label) => {
+                  var knopf = document.querySelector('#quellenliste button[aria-label="' + label + '"]');
+                  if (!knopf) throw new Error('Knopf fehlt: ' + label);
+                  knopf.click();
+                  for (var w = 0; w < 100; w++) {
+                    await new Promise((r) => setTimeout(r, 100));
+                    if (!document.getElementById('updatestart').disabled) break;
+                  }
+                  return document.querySelectorAll('#verlauf .block').length;
+                };
+                nachziehenBloeckeNachAnderer = await nachziehenLauf('kaputt-repo nachziehen');
+                nachziehenBloeckeNachEigener = await nachziehenLauf('skills-repo nachziehen');
+                nachziehenErsterBlock = document.querySelector('#verlauf .block')?.textContent?.replace(/\\s+/g, ' ').trim() ?? null;
+              } catch (fehler) {
+                nachziehenFehler = String(fehler);
+              }
               // E60: Beschreibung in der Ziel-Tabelle (nicht nur im Katalog), „manuell" entfällt,
               // Zahnrad statt Sonne am Einstellungen-Knopf.
               var zielBeschreibung = document.querySelector('#zielliste .linkliste .was')?.textContent ?? null;
@@ -1149,6 +1187,12 @@ function fensterOeffnen() {
                 verlaufVorhanden,
                 verlaufText,
                 verlaufBloecke,
+                nachziehenFehler,
+                nachziehenKnopfZahl,
+                nachziehenBloeckeStart,
+                nachziehenBloeckeNachAnderer,
+                nachziehenBloeckeNachEigener,
+                nachziehenErsterBlock,
                 zielsucheVorhanden,
                 zielzahlNachSuche,
                 zielKartenNachSucheZahl,
@@ -1168,6 +1212,34 @@ function fensterOeffnen() {
                     // E72: der Fenstertitel steht nicht im DOM (dort steht weiter der <title> der
                     // index.html), er lässt sich nur hier im Main-Prozess ablesen.
                     .then(() => console.log(`[smoke] Fenster: ${JSON.stringify({ fenstertitel: fenster.getTitle() })}`))
+                    // E90: erst nach dem DOM-Auszug die Platten-Erkennung auslösen (Naht über
+                    // HMGR_GUI_SMOKE_PLATTENVERSION), damit die Leer-Prüfungen der Update-Zeile darin gelten.
+                    // Danach ein zweiter, kleiner Auszug nur zum Neustart-Modal.
+                    .then(async () => {
+                    if (process.env.HMGR_GUI_SMOKE_PLATTENVERSION === undefined)
+                        return;
+                    plattenVersionPruefen(true);
+                    await new Promise((r) => setTimeout(r, 800));
+                    const auszug = await fenster.webContents.executeJavaScript(`(async () => {
+              var dlg = document.getElementById('d-neustart');
+              // Ein anderer Dialog steht noch offen (Rest des ersten Auszugs): das Modal wartet
+              // solange, und öffnet erst, wenn der andere zu ist.
+              var anderePlatzhalter = Array.from(document.querySelectorAll('dialog[open]')).filter(function (d) { return d !== dlg; });
+              var wartetSolangeAndererOffen = anderePlatzhalter.length > 0 && dlg?.open !== true;
+              anderePlatzhalter.forEach(function (d) { d.close(); });
+              await new Promise(function (r) { setTimeout(r, 300); });
+              var offen = dlg?.open === true;
+              var titel = document.getElementById('dn-titel')?.textContent ?? null;
+              var zeile = document.getElementById('selbstupdate-gui');
+              var zeileText = zeile && !zeile.hidden ? zeile.textContent : null;
+              var neustartKnopfSichtbar = document.getElementById('selbstupdate-neustart')?.hidden === false;
+              var knopfTexte = Array.from(dlg?.querySelectorAll('.dfuss button') ?? []).map(function (b) { return b.textContent; }).join('|');
+              dlg?.querySelector('button[value="spaeter"]')?.click();
+              var nachSpaeterOffen = dlg?.open === true;
+              return JSON.stringify({ wartetSolangeAndererOffen, offen, titel, zeileText, neustartKnopfSichtbar, knopfTexte, nachSpaeterOffen });
+            })()`);
+                    console.log(`[smoke] Neustart-Modal: ${String(auszug)}`);
+                })
                     .finally(() => app.quit());
             }, 3000);
         });
@@ -1181,7 +1253,10 @@ function fensterOeffnen() {
         fenster.webContents.once('did-finish-load', () => {
             fenster.webContents.send('hmgr:aktualisierenAnstossen', 'start');
         });
-        const intervall = setInterval(() => fenster.webContents.send('hmgr:aktualisierenAnstossen', 'intervall'), SECHS_STUNDEN_MS);
+        const intervall = setInterval(() => {
+            fenster.webContents.send('hmgr:aktualisierenAnstossen', 'intervall');
+            plattenVersionPruefen();
+        }, SECHS_STUNDEN_MS);
         fenster.on('closed', () => clearInterval(intervall));
     }
     // Die GUI erfährt von Änderungen außerhalb ihrer selbst (E62): Fokus-Reload und Datei-Watcher.
@@ -1190,7 +1265,10 @@ function fensterOeffnen() {
     // Aktualisieren (E44): ein Event dürfte sonst in den DOM-Auszug pfuschen.
     if (!smoketest) {
         const fenster = hauptfenster;
-        fenster.on('focus', () => neuLadenAnstossen());
+        fenster.on('focus', () => {
+            neuLadenAnstossen();
+            plattenVersionPruefen();
+        });
         void beobachtetePfade().then((pfade) => {
             if (fenster.isDestroyed())
                 return; // Fenster schon zu, während die Pfade ermittelt wurden
@@ -1247,7 +1325,8 @@ function updatePruefen() {
                     .catch((fehler) => {
                     console.log(`[verlauf] ${fehler instanceof Error ? fehler.message : String(fehler)}`);
                 });
-                selbstUpdateMelden({ art: 'gui', version: guiVersion });
+                geladenesPaketVorhanden = true;
+                selbstUpdateMelden({ art: 'gui', version: guiVersion, neuStartNoetig: 'geladen' });
             });
         }
         void autoUpdater.checkForUpdatesAndNotify().catch((fehler) => {
@@ -1264,6 +1343,44 @@ function selbstUpdateMelden(nachricht) {
         return;
     hauptfenster.webContents.send('hmgr:selbstUpdate', nachricht);
 }
+/** Windows: ein Paket ist geladen und wartet auf `quitAndInstall` (E90, Merker für `hmgr:neuStarten`). */
+let geladenesPaketVorhanden = false;
+/** Die beim Start festgehaltene Version des laufenden Prozesses. */
+const laufendeVersion = paketVersion();
+const PLATTEN_PRUEFUNG_MIN_ABSTAND_MS = 30_000;
+let letztePlattenPruefung = 0;
+let zuletztGemeldeteGuiVersion = null;
+/**
+ * E90, macOS-Weg: das App-Bundle wird im Hintergrund vom Deploy-Skript (ditto/rsync) ersetzt, der
+ * laufende Prozess merkt das nicht. Verglichen wird die Version in `Contents/Info.plist` mit der
+ * beim Start festgehaltenen. Die Info.plist statt der package.json in `app.asar`, weil Electron den
+ * asar-Header je Pfad zwischenspeichert und ein ersetztes Archiv nicht neu liest. Nur gepackt und
+ * nur auf macOS (nur dort gibt es ein Bundle mit Info.plist); gedrosselt auf einen Lauf je 30 s.
+ * Im Smoke-Test liefert `HMGR_GUI_SMOKE_PLATTENVERSION` eine künstliche Platten-Version, sonst
+ * läuft dort nie eine echte Prüfung.
+ */
+function plattenVersionPruefen(erzwingen = false) {
+    let platte;
+    if (smoketest) {
+        if (!erzwingen)
+            return;
+        const kuenstlich = process.env.HMGR_GUI_SMOKE_PLATTENVERSION;
+        platte = kuenstlich !== undefined && kuenstlich !== '' ? kuenstlich : null;
+    }
+    else {
+        if (!app.isPackaged || process.platform !== 'darwin')
+            return;
+        const jetzt = Date.now();
+        if (jetzt - letztePlattenPruefung < PLATTEN_PRUEFUNG_MIN_ABSTAND_MS)
+            return;
+        letztePlattenPruefung = jetzt;
+        platte = neuereVersionAufPlatte(infoPlistPfad(process.execPath), laufendeVersion);
+    }
+    if (platte === null || platte === zuletztGemeldeteGuiVersion)
+        return;
+    zuletztGemeldeteGuiVersion = platte;
+    selbstUpdateMelden({ art: 'gui', version: platte, neuStartNoetig: 'installiert' });
+}
 /**
  * Die daneben installierte hmgr-CLI gegen npm (E77, F83=O1). Läuft auf allen Plattformen — anders
  * als die GUI-Prüfung hängt sie an keinem Paket-Format und an keiner Signierung. Gemeldet wird nur,

package/dist/gui/renderer/index.html

@@ -255,6 +255,21 @@
   </form>
 </dialog>
 
+<!-- Neustart-Angebot (E90): ein Update für hmgr selbst liegt bereit. -->
+<dialog id="d-neustart">
+  <form method="dialog">
+    <div class="dkopf">
+      <span class="etikett">Update</span>
+      <h3 id="dn-titel"></h3>
+      <p>hmgr startet dafür neu. Offene Dialoge gehen dabei verloren.</p>
+    </div>
+    <div class="dfuss">
+      <button class="knopf leise" value="spaeter">Später</button>
+      <button class="knopf signal" value="jetzt">Jetzt neu starten</button>
+    </div>
+  </form>
+</dialog>
+
 <dialog id="d-erfolg">
   <form method="dialog">
     <div class="dkopf">

package/dist/gui/renderer/renderer.js

@@ -2629,7 +2629,9 @@
     standText();
   }
 
-  async function aktualisierenLauf(ausloeser) {
+  // Mit `quelle` (E89, Knopf „Nachziehen" der Quellenliste) läuft nur diese Quelle, sonst alles.
+  // Bericht, Stand-Zeile und Verlauf sind dieselben wie beim Kringel.
+  async function aktualisierenLauf(ausloeser, quelle) {
     var knopf = $('updatestart');
     if (knopf.disabled) return;
     knopf.disabled = true;
@@ -2637,7 +2639,9 @@
     standLaeuft = true;
     standText();
     var lauf = rufe(function () {
-      return window.hmgr.aktualisieren({ rueckfragen: ausloeser !== 'klick', ausloeser: ausloeser });
+      var args = { rueckfragen: ausloeser !== 'klick', ausloeser: ausloeser };
+      if (quelle) args.quelle = quelle;
+      return window.hmgr.aktualisieren(args);
     });
     // Jeder Lauf prüft auch hmgr selbst (E80): angestoßen, nicht abgewartet — ein Fund meldet sich
     // später von sich aus in der Seitenleiste (onSelbstUpdate).
@@ -2664,11 +2668,39 @@
      die CLI installiert die GUI nicht selbst (F82). Die CLI-Zeile ist seit E82 eine Warnung, keine
      bloße Ansage: eine alte CLI (vor 0.0.7, kennt --version nicht) schreibt dieselben Dateien
      (state.json, verlauf.json) wie die neue GUI und kennt Bundles, Verlauf und WSL-Heime nicht. */
+  /* Neustart-Modal (E90): je Version einmal. Nach „Später" kommt es für dieselbe Version nicht
+     wieder (nur im Speicher, ein App-Neustart setzt es zurück). Steht gerade ein anderer Dialog
+     offen, wartet es, bis der zu ist. */
+  var neustartAngebotVersion = null;
+  var neustartAbgelehnt = null;
+  function neustartAnbieten(version) {
+    if (version === neustartAbgelehnt) return;
+    neustartAngebotVersion = version;
+    neustartAngebotOeffnen();
+  }
+  function neustartAngebotOeffnen() {
+    if (neustartAngebotVersion === null || neustartAngebotVersion === neustartAbgelehnt) return;
+    if (document.querySelector('dialog[open]')) return;
+    $('dn-titel').textContent = 'hmgr ' + neustartAngebotVersion + ' ist bereit';
+    zeige($('d-neustart'));
+  }
+  $('d-neustart').addEventListener('close', function () {
+    if ($('d-neustart').returnValue === 'jetzt') window.hmgr.neuStarten();
+    else neustartAbgelehnt = neustartAngebotVersion;
+  });
+  // `close` bubbelt nicht, der Capture-Listener am Dokument sieht aber jeden geschlossenen Dialog.
+  document.addEventListener('close', function (ev) {
+    if (ev.target !== $('d-neustart')) setTimeout(neustartAngebotOeffnen, 0);
+  }, true);
+
   function selbstUpdateZeigen(nachricht) {
     if (nachricht.art === 'gui') {
-      $('selbstupdate-gui').textContent = 'hmgr ' + nachricht.version + ' bereit — wird beim Beenden installiert';
+      $('selbstupdate-gui').textContent = nachricht.neuStartNoetig === 'installiert'
+        ? 'hmgr ' + nachricht.version + ' ist installiert — Neustart lädt sie'
+        : 'hmgr ' + nachricht.version + ' bereit — wird beim Beenden installiert';
       $('selbstupdate-gui').hidden = false;
       $('selbstupdate-neustart').hidden = false;
+      neustartAnbieten(nachricht.version);
     } else if (nachricht.art === 'cli') {
       var p = $('selbstupdate-cli');
       p.textContent = '';
@@ -3539,6 +3571,17 @@
       stift.appendChild(stiftSvg);
       stift.addEventListener('click', function () { oeffneQuelleUmbenennen(q); });
       knoepfe.appendChild(stift);
+      // Nur diese Quelle nachziehen (E89): wie der Kringel in der Update-Ansicht, aber ohne
+      // Plugins, Aufräumen und übrige Quellen. Der Renderer kennt nur Text und Art (E54), die
+      // Quelle für den Kern baut er daraus.
+      var nachziehen = e('button', 'knopf leise klein nachziehen', 'Nachziehen');
+      nachziehen.type = 'button';
+      nachziehen.setAttribute('aria-label', q.name + ' nachziehen');
+      nachziehen.addEventListener('click', function () {
+        var quelle = q.art === 'lokal' ? { art: 'lokal', pfad: q.text } : { art: 'git', url: q.text };
+        aktualisierenLauf('klick', quelle);
+      });
+      knoepfe.appendChild(nachziehen);
       var weg = e('button', 'knopf leise klein', 'Entfernen …');
       weg.type = 'button';
       weg.setAttribute('aria-label', q.name + ' entfernen');

package/dist/gui/selbst-update.js

@@ -0,0 +1,74 @@
+// Erkennung „das App-Bundle auf der Platte ist neuer als der laufende Prozess" (E90). Reine
+// Funktionen ohne Electron-Import, damit sie ohne App testbar sind; das Verdrahten liegt in main.ts.
+import { readFileSync } from 'node:fs';
+import path from 'node:path';
+function zerlegen(version) {
+    const treffer = /^v?(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?(?:\+[0-9A-Za-z.-]+)?$/.exec(version.trim());
+    if (treffer === null)
+        return null;
+    return {
+        kern: [Number(treffer[1]), Number(treffer[2]), Number(treffer[3])],
+        vorab: treffer[4] === undefined ? [] : treffer[4].split('.'),
+    };
+}
+/** Semver-Rangfolge: negativ, 0 oder positiv; Vorabversion ist kleiner als ihre Release. */
+function vergleichen(a, b) {
+    for (let i = 0; i < 3; i++) {
+        const unterschied = a.kern[i] - b.kern[i];
+        if (unterschied !== 0)
+            return unterschied;
+    }
+    if (a.vorab.length === 0 && b.vorab.length === 0)
+        return 0;
+    if (a.vorab.length === 0)
+        return 1;
+    if (b.vorab.length === 0)
+        return -1;
+    for (let i = 0; i < Math.max(a.vorab.length, b.vorab.length); i++) {
+        const x = a.vorab[i];
+        const y = b.vorab[i];
+        if (x === undefined)
+            return -1;
+        if (y === undefined)
+            return 1;
+        const xZahl = /^\d+$/.test(x);
+        const yZahl = /^\d+$/.test(y);
+        if (xZahl && yZahl) {
+            if (Number(x) !== Number(y))
+                return Number(x) - Number(y);
+        }
+        else if (xZahl !== yZahl) {
+            return xZahl ? -1 : 1;
+        }
+        else if (x !== y) {
+            return x < y ? -1 : 1;
+        }
+    }
+    return 0;
+}
+/** `true`, wenn `platte` eine echt größere Version ist als `laufend`. Unlesbares gilt als „nein". */
+export function istNeuer(platte, laufend) {
+    const p = zerlegen(platte);
+    const l = zerlegen(laufend);
+    return p !== null && l !== null && vergleichen(p, l) > 0;
+}
+/** `…/hmgr.app/Contents/MacOS/hmgr` → `…/hmgr.app/Contents/Info.plist`. */
+export function infoPlistPfad(execPath) {
+    return path.join(path.dirname(execPath), '..', 'Info.plist');
+}
+/** Die CFBundleShortVersionString aus einer XML-Info.plist; `null` bei allem Unlesbaren. */
+export function plistVersion(plistPfad) {
+    try {
+        const text = readFileSync(plistPfad, 'utf8');
+        const treffer = /<key>CFBundleShortVersionString<\/key>\s*<string>([^<]*)<\/string>/.exec(text);
+        return treffer?.[1]?.trim() || null;
+    }
+    catch {
+        return null;
+    }
+}
+/** Die Platten-Version, wenn sie neuer ist als die laufende, sonst `null`. Wirft nie. */
+export function neuereVersionAufPlatte(plistPfad, laufend) {
+    const platte = plistVersion(plistPfad);
+    return platte !== null && istNeuer(platte, laufend) ? platte : null;
+}

package/dist/kern/anwendungsfaelle.js

@@ -1109,7 +1109,9 @@ export class Anwendungsfaelle {
     async bundleAbgleich(args) {
         const zustand = await this.p.zustand.lesen();
         const zielSchl = args?.ziel === undefined ? undefined : zielSchluessel(args.ziel);
+        const quelleSchl = args?.quelle === undefined ? undefined : quelleSchluessel(args.quelle);
         const installationen = zustand.bundleInstallationen.filter((i) => (args?.bundle === undefined || i.bundle === args.bundle) &&
+            (quelleSchl === undefined || quelleSchluessel(i.quelle) === quelleSchl) &&
             (zielSchl === undefined || zielSchluessel(Anwendungsfaelle.installationZiel(i)) === zielSchl));
         const ergebnis = [];
         for (const installation of installationen) {
@@ -1274,6 +1276,22 @@ export class Anwendungsfaelle {
         if ((await this.bindungFinden(ziel)) !== undefined)
             throw new ZeigerSchreibenGesperrt(ziel);
     }
+    /**
+     * Die eine geführte Quelle zu einem Teilstring (E89, `hmgr update --quelle`): verglichen wird mit
+     * Schreibweise (URL/Pfad), Schlüssel und Anzeigenamen, Groß- und Kleinschreibung egal. Kein Treffer
+     * und mehrere Treffer sind Fehler, mit der Liste, aus der sich der Nutzer eingrenzen kann.
+     */
+    async quelleZuHinweis(hinweis) {
+        const quellen = (await this.p.zustand.lesen()).quellen;
+        const klein = hinweis.toLowerCase();
+        const treffer = quellen.filter((q) => [quelleAlsText(q), quelleSchluessel(q), q.name ?? ''].some((t) => t.toLowerCase().includes(klein)));
+        const zeilen = (liste) => liste.map((q) => `  ${quelleAlsText(q)}${q.name === undefined ? '' : ` (${q.name})`}`).join('\n');
+        if (treffer.length === 1)
+            return treffer[0];
+        if (treffer.length === 0)
+            throw new Error(`Keine Quelle passt auf „${hinweis}".${quellen.length === 0 ? '' : `\nBekannte Quellen:\n${zeilen(quellen)}`}`);
+        throw new Error(`Mehrere Quellen passen auf „${hinweis}", bitte eingrenzen:\n${zeilen(treffer)}`);
+    }
     /** Skill über alle Quellen suchen. Mehrere Treffer sind nur mit Quellenhinweis erlaubt. */
     async skillFinden(name, quelleHinweis) {
         const zustand = await this.p.zustand.lesen();
@@ -1759,11 +1777,18 @@ export class Anwendungsfaelle {
      * ergeben hat: unveränderte oder übersprungene Checkouts und Bundles ohne Änderung erzeugen
      * nichts, ein leerer Lauf bleibt ganz aus dem Changelog. `ausloeser` steht mit im Eintrag, damit
      * der Verlauf zeigt, ob ein Fund vom automatischen Lauf, einem Klick oder der CLI kam.
+     *
+     * Mit `quelle` (E89) läuft nur diese geführte Quelle: ihre Checkouts, ihr Katalog-Fetch und die
+     * Bundle-Installationen, deren Definition in ihr liegt. Plugins, Aufräumen verwaister Checkouts
+     * und doctor entfallen (leere Ergebnisse), weil sie den Gesamtbestand betreffen.
      */
     async aktualisieren(args) {
         const rueckfragen = args?.rueckfragen ?? true;
         const ausloeser = args?.ausloeser ?? 'cli';
-        const bekannt = new Map((await this.p.zustand.lesen()).quellen.map((q) => [quelleSchluessel(q), q]));
+        const nurSchluessel = args?.quelle === undefined ? undefined : quelleSchluessel(args.quelle);
+        const bekannt = new Map((await this.p.zustand.lesen()).quellen
+            .filter((q) => nurSchluessel === undefined || quelleSchluessel(q) === nurSchluessel)
+            .map((q) => [quelleSchluessel(q), q]));
         const checkouts = [];
         for (const checkout of await this.p.quellen.checkouts()) {
             const gefuehrt = bekannt.get(quelleSchluessel(checkout.quelle));
@@ -1805,7 +1830,7 @@ export class Anwendungsfaelle {
         }
         // Nach den Checkouts die Plugins nachziehen (E14).
         const pluginHarnesses = [];
-        for (const harness of await this.vorhandeneHarnesses()) {
+        for (const harness of nurSchluessel !== undefined ? [] : await this.vorhandeneHarnesses()) {
             if (!kannPlugins(harness))
                 continue;
             await harness.plugins.aktualisieren();
@@ -1814,9 +1839,13 @@ export class Anwendungsfaelle {
         // Bundles vor dem Aufräumen (E69, F64=O1): der Abgleich legt und entfernt Links, und erst
         // danach steht fest, in welchen Checkout noch ein Link zeigt. Ein Fehlschlag je Bundle steckt
         // in seinem Eintrag, er bricht den Lauf nicht ab — wie eine unerreichbare Quelle (E51).
-        const bundles = await this.bundleAbgleich();
-        const aufraeumen = await this.verwaisteAufraeumen(checkouts, rueckfragen);
-        const doctorErgebnis = await this.doctor({ rueckfragen });
+        const bundles = await this.bundleAbgleich(args?.quelle === undefined ? undefined : { quelle: args.quelle });
+        const aufraeumen = nurSchluessel !== undefined
+            ? { 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, bundles, aufraeumen, doctorErgebnis));
         return { checkouts, pluginHarnesses, bundles, aufraeumen, doctor: doctorErgebnis };
     }

package/package.json

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