hmgr 0.0.42 → 0.0.44

package/dist/adapter/gui-signal.js

@@ -0,0 +1,29 @@
+// Signaldatei von der CLI an eine laufende GUI (E110): `<hmgrHome>/gui-signal.json`. Die CLI
+// schreibt sie nach `dir add` und Verwandten, die GUI beobachtet das Verzeichnis (src/gui/signal.ts).
+// Kein Port: der Kern kennt das Signal nicht, die Entscheidung „Signal ja/nein" fällt in der CLI.
+import { mkdir, readFile, rename, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+import { ohneBom } from "./datei-text.js";
+export const SIGNAL_DATEI = 'gui-signal.json';
+/** Atomar: Temp-Datei im selben Verzeichnis, dann rename darüber. */
+export async function signalSchreiben(hmgrHome, signal) {
+    await mkdir(hmgrHome, { recursive: true });
+    const ziel = path.join(hmgrHome, SIGNAL_DATEI);
+    const temp = path.join(hmgrHome, `${SIGNAL_DATEI}.${process.pid}.tmp`);
+    await writeFile(temp, `${JSON.stringify(signal)}\n`);
+    await rename(temp, ziel);
+}
+/** `undefined` bei fehlender, kaputter oder unbekannt geformter Datei. */
+export async function signalLesen(hmgrHome) {
+    try {
+        const roh = await readFile(path.join(hmgrHome, SIGNAL_DATEI), 'utf8');
+        const daten = JSON.parse(ohneBom(roh));
+        if (daten.art !== 'verzeichnis-zeigen' || typeof daten.pfad !== 'string' || typeof daten.zeit !== 'number') {
+            return undefined;
+        }
+        return { art: daten.art, pfad: daten.pfad, zeit: daten.zeit };
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/aenderungen.json

@@ -1,6 +1,12 @@
 {
   "fassung": 1,
   "versionen": {
+    "0.0.44": [
+      "Läuft gerade eine Aktualisierung, zeigt hmgr ein im Terminal hinzugefügtes Verzeichnis trotzdem sofort an, statt bis zum Ende der Aktualisierung zu warten."
+    ],
+    "0.0.43": [
+      "Fügst du im Terminal ein Arbeitsverzeichnis hinzu (hmgr dir add oder link mit einem neuen Verzeichnis), kommt ein offenes hmgr-Fenster nach vorn und zeigt das Verzeichnis sofort an."
+    ],
     "0.0.42": [
       "Der Verlauf meldet jetzt auch neue und entfernte Skills einer Quelle, nicht nur geänderte.",
       "Verlauf und „hmgr update“ sind leichter zu lesen: Quellen erscheinen mit ihrem Namen, darunter Neu, Entfernt und Geändert, ohne Commit-Kürzel. Quellen ohne Änderung an deinen Skills stehen gesammelt in einer Zeile am Ende."

package/dist/cli/hilfe.js

@@ -104,6 +104,10 @@ Plugins des Vorhabens stehen. Ohne Zeiger bleibt das Verzeichnis gemerkt und jed
 (E26). dir forget löst Bindung und Eintrag, die gelegten Links bleiben liegen. Gebunden wird nur für
 Harnesses, die hmgr verwaltet: standardmäßig nur claude-code (E38).
 
+Läuft die hmgr-GUI, kommt sie bei dir add nach vorn und zeigt das Verzeichnis (E110). Dasselbe
+passiert bei link, unlink, adopt, bundle add und plugin add mit --ort dir:<pfad>, wenn das Verzeichnis
+dabei neu gemerkt wird. Über SSH bleibt die GUI in Ruhe, und läuft keine GUI, passiert nichts.
+
 Ein Arbeitsverzeichnis unter Windows, das in einer WSL-Distro liegt (\\\\wsl$\\<distro>\\… oder
 \\\\wsl.localhost\\<distro>\\…, E96), bedient hmgr über die Bridge dieser Distro, wie ein Homedir in
 WSL: der Link liegt im Linux-Dateisystem und zeigt auf den Windows-Checkout (/mnt/c). MCP-Server
@@ -135,6 +139,9 @@ nur für ein Arbeitsverzeichnis mit composer.json, an Home und Profil bleibt jed
 Das Schreiben in einen Zeiger ist gesperrt, bis das Composer-Thema entschieden ist (E57): an einem
 Arbeitsverzeichnis mit Zeiger bricht link ohne --local ab, der Link wird nicht gelegt.
 
+Mit --ort dir:<pfad> kommt eine laufende hmgr-GUI nach vorn und zeigt das Verzeichnis, wenn es dabei
+neu gemerkt wird (nicht per SSH, E110).
+
 Schalter:
   --harness <name>    claude-code, hermes oder agents, Standard claude-code
   --ort <ort>         home, wsl:<distro>, dir:<pfad> oder profil:<name>, Standard home. profil

package/dist/cli/main.js

@@ -21,6 +21,7 @@ import { paketVersion } from "../adapter/paket-version.js";
 import { quelleAlsText, quelleAusText } from "../adapter/quelle-text.js";
 import { TerminalRueckfrage } from "../adapter/terminal.js";
 import { ProzessUmgebung } from "../adapter/umgebung.js";
+import { signalSchreiben } from "../adapter/gui-signal.js";
 import { ZustandJson } from "../adapter/zustand-json.js";
 import { VerlaufJson } from "../adapter/verlauf-json.js";
 import { AenderungenJson } from "../adapter/aenderungen-json.js";
@@ -259,6 +260,21 @@ const UEBERNAHME_GRUND = {
     'lokale-aenderungen': 'Ordner weicht von der Quelle ab',
     'nicht-pruefbar': 'hmgr kann nicht prüfen, ob der Ordner der Quelle entspricht',
 };
+/**
+ * E110: gibt einer laufenden GUI Bescheid, dass dieses Verzeichnis gezeigt werden soll. Nie bei
+ * SSH-Aufrufen, nie ein Grund zu scheitern.
+ */
+async function guiBenachrichtigen(umgebung, ports, pfad) {
+    try {
+        const variablen = ports.umgebung.variablen();
+        if ((variablen.SSH_CONNECTION ?? '') !== '' || (variablen.SSH_TTY ?? '') !== '')
+            return;
+        await signalSchreiben(umgebung.hmgrHome, { art: 'verzeichnis-zeigen', pfad, zeit: Date.now() });
+    }
+    catch {
+        // Das Signal ist ein Zusatz; das Kommando selbst hat funktioniert.
+    }
+}
 export async function ausfuehren(argv, umgebung, optionen = {}) {
     const { anwendungsfaelle, ports } = bauen(umgebung, optionen);
     const kommando = argv[0];
@@ -426,6 +442,7 @@ export async function ausfuehren(argv, umgebung, optionen = {}) {
             const ergebnis = composer === undefined
                 ? await anwendungsfaelle.arbeitsverzeichnisHinzufuegen(pfad)
                 : await anwendungsfaelle.arbeitsverzeichnisHinzufuegen(pfad, composer);
+            await guiBenachrichtigen(umgebung, ports, ergebnis.pfad);
             console.log(`Arbeitsverzeichnis ${ergebnis.pfad}`);
             if (ergebnis.zeigerPfad !== undefined)
                 console.log(`  Zeiger ${ergebnis.zeigerPfad}`);
@@ -465,10 +482,11 @@ export async function ausfuehren(argv, umgebung, optionen = {}) {
         if (ziel.ort.art === 'arbeitsverzeichnis') {
             // Verzeichnis merken und binden, damit status es wiederfindet und der Zeiger bekannt ist (E21).
             const composer = werte.get('composer');
-            if (composer === undefined)
-                await anwendungsfaelle.arbeitsverzeichnisHinzufuegen(ziel.ort.pfad);
-            else
-                await anwendungsfaelle.arbeitsverzeichnisHinzufuegen(ziel.ort.pfad, composer);
+            const verz = composer === undefined
+                ? await anwendungsfaelle.arbeitsverzeichnisHinzufuegen(ziel.ort.pfad)
+                : await anwendungsfaelle.arbeitsverzeichnisHinzufuegen(ziel.ort.pfad, composer);
+            if (verz.neu)
+                await guiBenachrichtigen(umgebung, ports, verz.pfad);
         }
         if (kommando === 'unlink') {
             const ergebnis = await anwendungsfaelle.linkEntfernen({ skill, ziel, lokal });
@@ -504,10 +522,11 @@ export async function ausfuehren(argv, umgebung, optionen = {}) {
         const name = rest[0];
         if (ziel.ort.art === 'arbeitsverzeichnis' && !probelauf) {
             const composer = werte.get('composer');
-            if (composer === undefined)
-                await anwendungsfaelle.arbeitsverzeichnisHinzufuegen(ziel.ort.pfad);
-            else
-                await anwendungsfaelle.arbeitsverzeichnisHinzufuegen(ziel.ort.pfad, composer);
+            const verz = composer === undefined
+                ? await anwendungsfaelle.arbeitsverzeichnisHinzufuegen(ziel.ort.pfad)
+                : await anwendungsfaelle.arbeitsverzeichnisHinzufuegen(ziel.ort.pfad, composer);
+            if (verz.neu)
+                await guiBenachrichtigen(umgebung, ports, verz.pfad);
         }
         const ergebnis = await anwendungsfaelle.uebernehmen({
             ziel,
@@ -568,10 +587,11 @@ export async function ausfuehren(argv, umgebung, optionen = {}) {
         const lokal = flaggen.has('local') || flaggen.has('lokal');
         if (ziel.ort.art === 'arbeitsverzeichnis') {
             const composer = werte.get('composer');
-            if (composer === undefined)
-                await anwendungsfaelle.arbeitsverzeichnisHinzufuegen(ziel.ort.pfad);
-            else
-                await anwendungsfaelle.arbeitsverzeichnisHinzufuegen(ziel.ort.pfad, composer);
+            const verz = composer === undefined
+                ? await anwendungsfaelle.arbeitsverzeichnisHinzufuegen(ziel.ort.pfad)
+                : await anwendungsfaelle.arbeitsverzeichnisHinzufuegen(ziel.ort.pfad, composer);
+            if (verz.neu)
+                await guiBenachrichtigen(umgebung, ports, verz.pfad);
         }
         const quelle = werte.get('quelle');
         const ergebnis = unterkommando === 'add'
@@ -627,10 +647,11 @@ export async function ausfuehren(argv, umgebung, optionen = {}) {
         if (ziel.ort.art === 'arbeitsverzeichnis') {
             // Wie bei link: Verzeichnis merken und binden, damit status es wiederfindet (E21).
             const composer = werte.get('composer');
-            if (composer === undefined)
-                await anwendungsfaelle.arbeitsverzeichnisHinzufuegen(ziel.ort.pfad);
-            else
-                await anwendungsfaelle.arbeitsverzeichnisHinzufuegen(ziel.ort.pfad, composer);
+            const verz = composer === undefined
+                ? await anwendungsfaelle.arbeitsverzeichnisHinzufuegen(ziel.ort.pfad)
+                : await anwendungsfaelle.arbeitsverzeichnisHinzufuegen(ziel.ort.pfad, composer);
+            if (verz.neu)
+                await guiBenachrichtigen(umgebung, ports, verz.pfad);
         }
         if (unterkommando === 'add') {
             const quelle = werte.get('quelle');

package/dist/gui/main.js

@@ -21,6 +21,8 @@ import { iconFuerQuelle } from "./icons.js";
 import { entscheideOeffnen } from "./oeffnen.js";
 import { mcpUebernahmeSerialisieren, mcpUebersichtSerialisieren, mcpWirkungSerialisieren } from "./mcp-ansicht.js";
 import { beobachten } from "./beobachter.js";
+import { signalSchreiben } from "../adapter/gui-signal.js";
+import { signalBeobachten } from "./signal.js";
 import { loginPathUebernehmen } from "./login-pfad.js";
 import { hmgrCliVersion } from "./hmgr-cli.js";
 import { cliUpdateHinweis } from "../adapter/npm-registry.js";
@@ -505,6 +507,7 @@ function neuLadenAnstossenFabrik(minAbstandMs) {
 }
 const neuLadenAnstossen = neuLadenAnstossenFabrik(FOKUS_RELOAD_MIN_ABSTAND_MS);
 let beobachter;
+let signalBeobachter;
 function fensterOeffnen() {
     hauptfenster = new BrowserWindow({
         width: 1280,
@@ -1367,6 +1370,87 @@ function fensterOeffnen() {
                     await new Promise((r) => setTimeout(r, 800));
                     const auszug = await fenster.webContents.executeJavaScript(NEUSTART_AUSZUG_SKRIPT);
                     console.log(`[smoke] Neustart-Modal: ${String(auszug)}`);
+                })
+                    // E110: CLI-Signal gegen die laufende GUI. Das Signal schreibt dieser Main-Prozess in das
+                    // Wegwerf-Home (der Renderer kann keine Dateien schreiben). Fall 1: ohne Dialog springt die
+                    // GUI aus einer anderen Ansicht zur Karte. Fall 2: mit offenem Dialog bleibt alles stehen,
+                    // erst nach dem Schließen folgt der Sprung. Fall 3 (E112): bei laufendem Aktualisieren lädt das Signal trotzdem, der Watcher nicht. Läuft nach der Neustart-Modal-Prüfung, weil der Fall
+                    // offene Dialoge schließt.
+                    .then(async () => {
+                    const pfade = (process.env.HMGR_GUI_SMOKE_SIGNAL_PFADE ?? '').split('\n').filter((p) => p !== '');
+                    if (pfade.length < 2)
+                        return;
+                    const [pfad1, pfad2] = pfade;
+                    const js = (code) => fenster.webContents.executeJavaScript(code);
+                    const karteJs = (pfad) => `(function () {
+              var schluessel = ${JSON.stringify(`dir:${pfad}`)};
+              var karte = Array.from(document.querySelectorAll('#zielliste .ziel.verzeichnis'))
+                .find(function (k) { return k.dataset.verzKey === schluessel; });
+              return {
+                karte: karte !== undefined,
+                zieleSichtbar: document.getElementById('ansicht-ziele').hidden === false,
+                aufgeklappt: karte?.querySelector('.zielkopf')?.getAttribute('aria-expanded') ?? null,
+              };
+            })()`;
+                    const warteAufSprung = async (pfad) => {
+                        let stand = null;
+                        for (let ms = 0; ms < 4000; ms += 100) {
+                            await new Promise((r) => setTimeout(r, 100));
+                            stand = await js(karteJs(pfad));
+                            const k = stand;
+                            if (k.zieleSichtbar && k.aufgeklappt === 'true')
+                                break;
+                        }
+                        return stand;
+                    };
+                    const ergebnis = {};
+                    try {
+                        await js(`new Promise(function (r) { var n = 0; (function w() { if (document.querySelector('dialog[open]') || ++n > 30) r(); else setTimeout(w, 50); })(); })`);
+                        await js(`document.querySelectorAll('dialog[open]').forEach(function (d) { d.close(); });
+                document.querySelector('[data-ansicht="mcp"]').click(); true`);
+                        ergebnis.fall1Vorher = await js(karteJs(pfad1));
+                        await signalSchreiben(umgebung.hmgrHome, { art: 'verzeichnis-zeigen', pfad: pfad1, zeit: Date.now() });
+                        ergebnis.fall1 = await warteAufSprung(pfad1);
+                        // Fall 2: Dialog offen, andere Ansicht, Signal für ein anderes Verzeichnis.
+                        await js(`document.querySelector('[data-ansicht="mcp"]').click();
+                document.getElementById('d-einstellungen').showModal(); true`);
+                        ergebnis.fall2Vorher = await js(karteJs(pfad2));
+                        await signalSchreiben(umgebung.hmgrHome, { art: 'verzeichnis-zeigen', pfad: pfad2, zeit: Date.now() });
+                        await new Promise((r) => setTimeout(r, 1500));
+                        ergebnis.fall2Offen = await js(`({ dialogOffen: document.getElementById('d-einstellungen').open === true, ` +
+                            `ansichtMcp: document.getElementById('ansicht-mcp').hidden === false })`);
+                        ergebnis.fall2NachWarten = await js(karteJs(pfad2));
+                        await js(`document.getElementById('d-einstellungen').close(); true`);
+                        ergebnis.fall2 = await warteAufSprung(pfad2);
+                        // Fall 3 (E112): ein Aktualisieren-Lauf läuft (so erkennt ihn der Renderer: der
+                        // Kringel ist gesperrt). Ein Watcher-/Fokus-Anstoß lädt nicht; das Signal lädt sofort
+                        // und springt trotzdem. Ein MutationObserver an der Zielliste belegt das Neuladen
+                        // (ladeAlles baut sie neu auf). Karte von Fall 1 vorher zuklappen, Ansicht wechseln.
+                        await js(`window.__e112Aenderungen = 0;
+                window.__e112Beobachter = new MutationObserver(function (m) { window.__e112Aenderungen += m.length; });
+                window.__e112Beobachter.observe(document.getElementById('zielliste'), { childList: true, subtree: true });
+                document.getElementById('updatestart').disabled = true;
+                document.querySelector('[data-ansicht="mcp"]').click(); true`);
+                        await js(`(function () {
+                var k = Array.from(document.querySelectorAll('#zielliste .ziel.verzeichnis'))
+                  .find(function (x) { return x.dataset.verzKey === ${JSON.stringify(`dir:${pfad1}`)}; });
+                var kopf = k.querySelector('.zielkopf');
+                if (kopf.getAttribute('aria-expanded') === 'true') kopf.click();
+                window.__e112Aenderungen = 0; return true; })()`);
+                        ergebnis.fall3Vorher = await js(karteJs(pfad1));
+                        fenster.webContents.send('hmgr:neuLadenAnstossen');
+                        await new Promise((r) => setTimeout(r, 1200));
+                        ergebnis.fall3WatcherAenderungen = await js(`window.__e112Aenderungen`);
+                        await signalSchreiben(umgebung.hmgrHome, { art: 'verzeichnis-zeigen', pfad: pfad1, zeit: Date.now() });
+                        ergebnis.fall3 = await warteAufSprung(pfad1);
+                        ergebnis.fall3Aenderungen = await js(`window.__e112Aenderungen`);
+                        ergebnis.fall3LaufNochGesperrt = await js(`document.getElementById('updatestart').disabled === true`);
+                        await js(`document.getElementById('updatestart').disabled = false; window.__e112Beobachter.disconnect(); true`);
+                    }
+                    catch (fehler) {
+                        ergebnis.fehler = String(fehler);
+                    }
+                    console.log(`[smoke] Signal: ${JSON.stringify(ergebnis)}`);
                 })
                     .finally(() => app.quit());
             }, 3000);
@@ -1407,6 +1491,26 @@ function fensterOeffnen() {
             beobachter = undefined;
         });
     }
+    // CLI-Signal (E110): `hmgr dir add` und Verwandte schreiben `gui-signal.json` ins hmgr-Home. Anders
+    // als der Watcher oben ohne Entprellen und ohne Drossel; läuft auch im Smoke-Test (mit dessen
+    // Wegwerf-Home), dort aber ohne Fokusklau.
+    {
+        const fenster = hauptfenster;
+        signalBeobachter = signalBeobachten(umgebung.hmgrHome, (pfad) => {
+            if (fenster.isDestroyed())
+                return;
+            if (!smoketest) {
+                fensterNachVornHolen();
+                if (process.platform === 'darwin')
+                    app.focus({ steal: true });
+            }
+            fenster.webContents.send('hmgr:verzeichnisZeigen', pfad);
+        });
+        fenster.on('closed', () => {
+            signalBeobachter?.close();
+            signalBeobachter = undefined;
+        });
+    }
     void hauptfenster.loadFile(path.join(hierVerzeichnis, 'renderer', 'index.html'));
 }
 const { autoUpdater } = electronUpdater;

package/dist/gui/preload.cjs

@@ -79,6 +79,11 @@ contextBridge.exposeInMainWorld('hmgr', {
     onNeuLadenAnstossen: (hoerer) => {
         ipcRenderer.on('hmgr:neuLadenAnstossen', () => hoerer());
     },
+    /** Signal der CLI (E110): ein Arbeitsverzeichnis soll gezeigt werden. Main hat das Fenster schon
+        nach vorn geholt; kein Entprellen, keine Drossel. */
+    onVerzeichnisZeigen: (hoerer) => {
+        ipcRenderer.on('hmgr:verzeichnisZeigen', (_event, pfad) => hoerer(pfad));
+    },
     /** Prüfung auf neue hmgr-Stände (E77), angestoßen bei jedem Aktualisieren-Lauf (E80: Start,
         Intervall, Klick). Antwortet nicht, meldet sich später über onSelbstUpdate — Netz und Spawn
         dauern länger als ein Knopfdruck. */

package/dist/gui/renderer/renderer.js

@@ -2797,7 +2797,7 @@
       var uhrzeit = new Date().toLocaleTimeString('de-DE', { hour: '2-digit', minute: '2-digit' });
       standNachLauf(ergebnis, ausloeser, uhrzeit);
       await ladeVerlauf();
-      await ladeAlles();
+      await ladeAllesNacheinander();
     } finally {
       standLaeuft = false;
       knopf.disabled = false;
@@ -2883,6 +2883,15 @@
   // überholt. Fehler landen wie sonst über rufe() in der Meldungsleiste, kein stiller Absturz.
   var stillerReloadLaeuft = false;
   var stillerReloadVorgemerkt = false;
+  // Alle Neuaufbauten der stillen Wege, des Signals und des Laufendes (E112) laufen hintereinander,
+  // nie gleichzeitig. Die Kette reißt nie: ein Fehler (rufe() hat ihn gemeldet) wird für die
+  // Kette verschluckt, dem Aufrufer aber weitergereicht.
+  var ladeKette = Promise.resolve();
+  function ladeAllesNacheinander() {
+    var lauf = ladeKette.then(function () { return ladeAlles(); });
+    ladeKette = lauf.catch(function () {});
+    return lauf;
+  }
   async function stillerReload() {
     // Läuft gerade ein Aktualisieren-Lauf, wird nicht parallel geladen: er endet ohnehin mit
     // ladeAlles und nimmt die Änderung mit. Sonst bauten zwei Läufe gleichzeitig die Ansicht auf.
@@ -2893,7 +2902,7 @@
     }
     stillerReloadLaeuft = true;
     try {
-      await ladeAlles();
+      await ladeAllesNacheinander();
     } catch (fehler) {
       // rufe() hat den Fehler schon gemeldet, hier bleibt nur: den Durchlauf nicht wiederholen.
     } finally {
@@ -2906,6 +2915,31 @@
   }
   window.hmgr.onNeuLadenAnstossen(function () { void stillerReload(); });
 
+  // CLI-Signal (E110, nach `hmgr dir add` und Verwandten): sofort neu laden, dann zur Karte des
+  // Verzeichnisses springen, auch aus einer anderen Ansicht. Steht ein Dialog offen, bleibt er
+  // unangetastet und der Sprung wartet, bis kein Dialog mehr offen ist; ein neueres Signal ersetzt
+  // die Vormerkung. Die Meldungsleiste bleibt, wie sie ist.
+  var signalPfadVorgemerkt = null;
+  function signalSprungEinloesen() {
+    if (signalPfadVorgemerkt === null) return;
+    if (document.querySelector('dialog[open]')) return;
+    var pfad = signalPfadVorgemerkt;
+    signalPfadVorgemerkt = null;
+    // Eine E84-Vormerkung auf denselben Pfad ist mit diesem Sprung erledigt.
+    if (zielSprungVorgemerkt === pfad) zielSprungVorgemerkt = null;
+    zeigeAnsicht('ziele');
+    springeZuVerzeichnis(pfad);
+  }
+  // Der Signalweg lädt sofort, auch während eines Aktualisieren-Laufs (E112); die Serialisierung
+  // hält ihn von dessen Neuaufbau am Ende getrennt. Der Sprung folgt auch nach einem Fehler.
+  window.hmgr.onVerzeichnisZeigen(function (pfad) {
+    signalPfadVorgemerkt = pfad;
+    void ladeAllesNacheinander().catch(function () {}).then(signalSprungEinloesen);
+  });
+  // `close` bubbelt nicht, der Capture-Listener am Dokument sieht aber jeden geschlossenen Dialog.
+  // Der Aufschub um einen Takt lässt einen unmittelbar folgenden Dialog zuerst aufgehen.
+  document.addEventListener('close', function () { setTimeout(signalSprungEinloesen, 0); }, true);
+
   /**
    * Eine Ereigniszeile im Verlauf (E80): Marke + Text, Muster wie die frühere baueBericht-Zeile
    * und die CLI-Ausgabe (verlaufEreignisZeile, src/cli/main.ts). Checkouts stellt

package/dist/gui/signal.js

@@ -0,0 +1,58 @@
+// Beobachter für das CLI-Signal (E110), ohne Electron-Import (testbar wie beobachter.ts). Beobachtet
+// wird das Verzeichnis hmgrHome mit Filter auf `gui-signal.json` (aus demselben Grund wie in
+// beobachter.ts: die Datei wird per rename ersetzt, ein Watcher auf die Datei würde taub).
+// Anders als beobachter.ts kein Entprellen und kein Inhaltsvergleich: jedes frische Signal zählt.
+import { watch } from 'node:fs';
+import { SIGNAL_DATEI, signalLesen } from "../adapter/gui-signal.js";
+export function signalBeobachten(hmgrHome, callback, optionen = {}) {
+    const sammelnMs = optionen.sammelnMs ?? 30;
+    const maxAlterMs = optionen.maxAlterMs ?? 10_000;
+    let timer;
+    let geschlossen = false;
+    let zuletzt;
+    // Eine beim Start vorhandene Datei gilt als schon gesehen. Das Alter allein reicht nicht: auf macOS
+    // liefert fs.watch kurz nach dem Anlegen auch Events für Schreibvorgänge kurz davor.
+    const startStand = signalLesen(hmgrHome).then((signal) => {
+        if (signal !== undefined)
+            zuletzt = `${signal.zeit}\u0000${signal.pfad}`;
+    });
+    async function auswerten() {
+        await startStand;
+        const signal = await signalLesen(hmgrHome);
+        if (geschlossen || signal === undefined)
+            return;
+        if (Date.now() - signal.zeit > maxAlterMs)
+            return;
+        const schluessel = `${signal.zeit}\u0000${signal.pfad}`;
+        if (schluessel === zuletzt)
+            return;
+        zuletzt = schluessel;
+        callback(signal.pfad);
+    }
+    let watcher;
+    try {
+        watcher = watch(hmgrHome, (_ereignis, name) => {
+            if (geschlossen)
+                return;
+            if (name !== null && name !== SIGNAL_DATEI)
+                return;
+            if (timer !== undefined)
+                return; // schon ein Lesen eingeplant
+            timer = setTimeout(() => {
+                timer = undefined;
+                void auswerten();
+            }, sammelnMs);
+        });
+    }
+    catch {
+        // Verzeichnis fehlt: unbeobachtet.
+    }
+    return {
+        close() {
+            geschlossen = true;
+            if (timer !== undefined)
+                clearTimeout(timer);
+            watcher?.close();
+        },
+    };
+}

package/dist/kern/anwendungsfaelle.js

@@ -1322,7 +1322,8 @@ export class Anwendungsfaelle {
                 hinweis = `Kein Zeiger unter ${verzeichnis}, alles bleibt lokal (E26).`;
         }
         const zustand = await this.p.zustand.lesen();
-        if (!zustand.arbeitsverzeichnisse.includes(verzeichnis))
+        const neu = !zustand.arbeitsverzeichnisse.includes(verzeichnis);
+        if (neu)
             zustand.arbeitsverzeichnisse.push(verzeichnis);
         if (zeigerPfad !== undefined) {
             const gebunden = zeigerPfad;
@@ -1338,6 +1339,7 @@ export class Anwendungsfaelle {
         await this.p.zustand.schreiben(zustand);
         return {
             pfad: verzeichnis,
+            neu,
             ...(zeigerPfad === undefined ? {} : { zeigerPfad }),
             ...(hinweis === undefined ? {} : { hinweis }),
         };

package/package.json

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