hmgr 0.0.4 → 0.0.6

package/dist/kern/anwendungsfaelle.js

@@ -1,8 +1,8 @@
 // Anwendungsfälle. Pfade werden hier nur als Zeichenketten normalisiert, gelesen wird über die Ports.
 import path from 'node:path';
-import { AbhaengigkeitFehlt, EinschraenkungOhneZeiger, HarnessNichtVorhanden, KeinPassenderRef, OrtNichtUnterstuetzt, PluginMehrdeutig, PluginUnbekannt, SkillMehrdeutig, SkillUnbekannt, ZeigerMehrdeutig, marketplaceUrl, pluginSchluessel, pluginSchluesselZerlegen, quelleAlsText, quelleSchluessel, zielSchluessel, } from "./modell.js";
+import { AbhaengigkeitFehlt, EinschraenkungOhneZeiger, FremderEintragUnbekannt, HarnessNichtVorhanden, HarnessTypUnbekannt, KeinPassenderRef, McpEbeneNichtUnterstuetzt, McpFaehigkeitFehlt, McpUebernahmeNichtMoeglich, McpUnbekannt, OrtNichtUnterstuetzt, PluginMehrdeutig, PluginUnbekannt, QuelleAufraeumenLokaleAenderungen, QuelleNameBelegt, QuelleUnbekannt, SkillMehrdeutig, SkillOrdnerBereitsVerwaltet, SkillOrdnerFaehigkeitFehlt, SkillOrdnerNichtVerwaltet, SkillUnbekannt, ZeigerMehrdeutig, ZeigerSchreibenGesperrt, marketplaceUrl, pluginSchluessel, pluginSchluesselZerlegen, quelleAlsText, quelleMitNamen, quelleName, quelleNameAbleiten, quelleNameFrei, quelleSchluessel, zielSchluessel, } from "./modell.js";
 import { passenderRef } from "./version.js";
-import { kannPlugins, kannProfile } from "../ports/harness.js";
+import { kannIstRegistriert, kannMcp, kannPlugins, kannProfile, kannSkillOrdner, kannZurueckbauen, } from "../ports/harness.js";
 /**
  * Frage vor dem Löschen, eine für alle Kandidaten (E28). Der Kern formuliert sie fertig, der
  * Adapter stellt sie: Anzahl und Pfade, damit der Nutzer sieht, worüber er entscheidet.
@@ -12,14 +12,34 @@ export function aufraeumFrage(checkouts) {
         ? 'Ein Checkout ist verwaist, kein Link zeigt hinein:'
         : `${checkouts.length} Checkouts sind verwaist, kein Link zeigt hinein:`;
     const pfade = checkouts.map((c) => `  ${c.pfad}`).join('\n');
-    return `${kopf}\n${pfade}\nLöschen? [j/N]`;
+    return `${kopf}\n${pfade}\nLöschen?`;
 }
 function arbeitsverzeichnisZiel(harness, pfad) {
     return { harness, ort: { art: 'arbeitsverzeichnis', pfad } };
 }
+/** Gleichheit eines ignorierten Eintrags mit einem Ziel plus Name (E43): harness, Ort strukturell, Name. */
+function ignorierterEintragGleich(i, args) {
+    return zielSchluessel({ harness: i.harness, ort: i.ort }) === zielSchluessel(args.ziel) && i.name === args.name;
+}
 function fehlertext(fehler) {
     return fehler instanceof Error ? fehler.message : String(fehler);
 }
+/**
+ * `${VAR}`- und `${env:VAR}`-Verweise in einem MCP-Konfigblock, ohne Dubletten (E61, F39).
+ * Exportiert, damit die GUI dieselbe Prüfung für den Warn-Vermerk an der Katalog-Karte
+ * wiederverwenden kann (E61-Folgerunde), statt sie nachzubauen.
+ */
+export function variablenVerweise(konfig) {
+    const texte = 'command' in konfig
+        ? [konfig.command, ...(konfig.args ?? []), ...Object.values(konfig.env ?? {})]
+        : [konfig.url, ...Object.values(konfig.headers ?? {})];
+    const namen = new Set();
+    const muster = /\$\{(?:env:)?([A-Za-z_][A-Za-z0-9_]*)\}/g;
+    for (const text of texte)
+        for (const treffer of text.matchAll(muster))
+            namen.add(treffer[1]);
+    return [...namen];
+}
 /**
  * Quellenhinweis bei Mehrdeutigkeit (E12): Teilstring des Schlüssels oder der Schreibweise. Beides
  * zählt, damit `host/besitzer/repo` genauso greift wie ein Stück der URL, unter der die Quelle
@@ -30,6 +50,17 @@ function quellePasst(quelle, hinweis) {
         return true;
     return quelleSchluessel(quelle).includes(hinweis) || quelleAlsText(quelle).includes(hinweis);
 }
+/** Ordnerpfad eines Skills relativ zur Quelle, aus `skillPath` des Lockfiles (E48 b): das `SKILL.md`-Suffix fällt weg. */
+function skillPfadAusLock(skillPath) {
+    let pfad = skillPath.replace(/\\/g, '/');
+    if (pfad.endsWith('/SKILL.md'))
+        pfad = pfad.slice(0, -'/SKILL.md'.length);
+    else if (pfad.endsWith('SKILL.md'))
+        pfad = pfad.slice(0, -'SKILL.md'.length);
+    if (pfad.endsWith('/'))
+        pfad = pfad.slice(0, -1);
+    return pfad;
+}
 export class Anwendungsfaelle {
     p;
     /** Schon beantwortete Orte, je Ziel der Hinweis, der davon übrig blieb (E34). */
@@ -42,7 +73,7 @@ export class Anwendungsfaelle {
     harness(name) {
         const h = this.p.harnesses.find((h) => h.name === name);
         if (!h)
-            throw new Error(`Unbekannter Harness „${name}"`);
+            throw new HarnessTypUnbekannt(name);
         return h;
     }
     /** Ein namentlich genannter Harness muss auf dem Rechner liegen, sonst passiert nichts Stilles. */
@@ -68,25 +99,423 @@ export class Anwendungsfaelle {
                 ergebnis.push(harness.name);
         return ergebnis;
     }
+    /** Namen aller Harness-Typen, die hmgr kennt, aktiv oder nicht. Reine Aufzählung, ohne Regel. */
+    harnessTypen() {
+        return this.p.harnesses.map((h) => h.name);
+    }
+    /**
+     * Harness-Typen, die hmgr verwaltet (E38, GRILL.md Runde 2). Nur für sie richtet hmgr beim
+     * Arbeitsverzeichnis-Hinzufügen und beim Abgleich etwas ein. Standard: nur claude-code.
+     */
+    async aktiveHarnesses() {
+        return (await this.p.zustand.lesen()).aktiveHarnesses;
+    }
+    /** Vorhandene Harnesses, gefiltert auf die aktiven (E38). Für Einrichten-Abläufe über alle Harnesses. */
+    async vorhandeneAktiveHarnesses() {
+        const aktiv = new Set(await this.aktiveHarnesses());
+        return (await this.vorhandeneHarnesses()).filter((h) => aktiv.has(h.name));
+    }
+    /** Aktiviert einen Harness-Typ (E38). Unbekannter Name ist ein Fehler, schon aktiv ist keiner. */
+    async harnessAktivieren(name) {
+        this.harness(name); // wirft HarnessTypUnbekannt bei unbekanntem Namen
+        const zustand = await this.p.zustand.lesen();
+        if (zustand.aktiveHarnesses.includes(name))
+            return;
+        zustand.aktiveHarnesses.push(name);
+        await this.p.zustand.schreiben(zustand);
+    }
+    /**
+     * Deaktiviert einen Harness-Typ (E38). Unbekannter Name ist ein Fehler, schon inaktiv ist keiner.
+     * Säubert nicht automatisch: liegende Konfiguration meldet die GUI über `istZustand`, entfernt
+     * wird sie erst mit `saeubern`.
+     */
+    async harnessDeaktivieren(name) {
+        this.harness(name); // wirft HarnessTypUnbekannt bei unbekanntem Namen
+        const zustand = await this.p.zustand.lesen();
+        if (!zustand.aktiveHarnesses.includes(name))
+            return;
+        zustand.aktiveHarnesses = zustand.aktiveHarnesses.filter((h) => h !== name);
+        await this.p.zustand.schreiben(zustand);
+    }
+    /** Ein Harness mit der Fähigkeit „verwalteter Skill-Ordner" (E56), sonst `SkillOrdnerFaehigkeitFehlt`. */
+    harnessMitSkillOrdner(name) {
+        const harness = this.harness(name);
+        if (!kannSkillOrdner(harness))
+            throw new SkillOrdnerFaehigkeitFehlt(name);
+        return harness;
+    }
+    /** Der verwaltete Skill-Ordner eines Ziels (E56), oder `undefined`, wenn keiner verwaltet wird. */
+    async verwalteterSkillOrdner(ziel) {
+        await this.harnessGeprueft(ziel.harness);
+        return this.harnessMitSkillOrdner(ziel.harness).verwalteterSkillOrdner(ziel.ort);
+    }
+    /**
+     * Skill-Ordner festlegen (E56): erlaubt nur, wenn für dieses Ziel noch keiner verwaltet wird
+     * (sonst `SkillOrdnerBereitsVerwaltet`). Den genannten Pfad deutet und prüft die Fähigkeit selbst
+     * (unterhalb des Hermes-Home, nicht der eigene Ordner), sie kennt den Aufbau; der Kern reicht ihn
+     * unverändert durch und gibt den aufgelösten Pfad zurück.
+     */
+    async skillOrdnerFestlegen(ziel, pfad) {
+        const harness = await this.harnessGeprueft(ziel.harness);
+        const faehig = this.harnessMitSkillOrdner(harness.name);
+        const vorhanden = await faehig.verwalteterSkillOrdner(ziel.ort);
+        if (vorhanden !== undefined)
+            throw new SkillOrdnerBereitsVerwaltet(ziel, vorhanden);
+        return await faehig.skillOrdnerFestlegen(ziel.ort, pfad);
+    }
+    /**
+     * Skill-Ordner entfernen (E56): nur der Eintrag in der Harness-Konfiguration verschwindet, der
+     * Ordner bleibt liegen. Erhebt vorher den Inhalt (hmgr-Links, fremde Einträge), wie `istZustand`
+     * ihn für dieses Ziel zeigen würde, fürs anschließende Lösch-Angebot des Aufrufers. Ohne
+     * verwalteten Eintrag: `SkillOrdnerNichtVerwaltet`.
+     */
+    async skillOrdnerEntfernen(ziel) {
+        const harness = await this.harnessGeprueft(ziel.harness);
+        const faehig = this.harnessMitSkillOrdner(harness.name);
+        const pfad = await faehig.verwalteterSkillOrdner(ziel.ort);
+        if (pfad === undefined)
+            throw new SkillOrdnerNichtVerwaltet(ziel);
+        const eintraege = await this.p.ziele.eintraege(ziel, pfad).catch(() => []);
+        const hmgrLinks = eintraege.filter((e) => e.art !== 'fremd').length;
+        const fremdeEintraege = eintraege.filter((e) => e.art === 'fremd').length;
+        await faehig.skillOrdnerEntfernen(ziel.ort);
+        return { ziel, pfad, hmgrLinks, fremdeEintraege };
+    }
+    /**
+     * Den zuvor verwalteten Skill-Ordner mit Inhalt löschen (E56), ein eigener, destruktiver Schritt
+     * nach `skillOrdnerEntfernen`. Die Bestätigung liegt beim Aufrufer (CLI über den Rückfrage-Port,
+     * GUI über einen eigenen Dialog), hier nur die Ausführung samt Sicherheitsnetz in der Fähigkeit.
+     */
+    async skillOrdnerLoeschen(ziel, pfad) {
+        const harness = await this.harnessGeprueft(ziel.harness);
+        await this.harnessMitSkillOrdner(harness.name).skillOrdnerLoeschen(ziel.ort, pfad);
+    }
+    /** Ein Harness mit der Fähigkeit MCP-Server (E61), sonst `McpFaehigkeitFehlt`. */
+    harnessMitMcp(name) {
+        const harness = this.harness(name);
+        if (!kannMcp(harness))
+            throw new McpFaehigkeitFehlt(name);
+        return harness;
+    }
+    /** MCP-Katalog, unverändert wie in ~/.hmgr/mcp.yaml gepflegt (E61). hmgr schreibt ihn nie. */
+    async mcpKatalog() {
+        return await this.p.mcpKatalog.lesen();
+    }
+    async mcpEintragFinden(mcpName) {
+        const eintrag = (await this.p.mcpKatalog.lesen()).find((e) => e.name === mcpName);
+        if (eintrag === undefined)
+            throw new McpUnbekannt(mcpName);
+        return eintrag;
+    }
+    /**
+     * 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.
+     */
+    async mcpVariablenWarnung(faehig, eintrag, ort) {
+        const verweise = variablenVerweise(eintrag.konfig);
+        if (verweise.length === 0)
+            return undefined;
+        const prozessEnv = this.p.umgebung.variablen();
+        const envPfad = faehig.mcp.envDatei?.(ort);
+        const zusatzEnv = envPfad === undefined ? {} : await this.p.umgebung.envDatei(envPfad);
+        const fehlend = verweise.filter((v) => !(v in prozessEnv) && !(v in zusatzEnv));
+        if (fehlend.length === 0)
+            return undefined;
+        const mehrzahl = fehlend.length > 1;
+        return (`hmgr kann nicht wissen, was die Shell beim Start des Harness setzt: ` +
+            `${mehrzahl ? 'Variablen' : 'Variable'} ${fehlend.join(', ')} ${mehrzahl ? 'sind' : 'ist'} weder in der ` +
+            'aktuellen Umgebung noch in einer bekannten .env-Datei zu finden.');
+    }
+    /**
+     * MCP einhängen (E61): Katalog-Eintrag an ein Ziel legen, Projekt oder global. Die Fähigkeit hängt
+     * am Adapter (E16): ein Harness ohne MCP-Fähigkeit oder ohne diese Ebene ist ein Fehler. Ein
+     * fehlender `${VAR}`-Verweis bricht nicht ab, sondern kommt als Warnung zurück (F39).
+     */
+    async mcpEinhaengen(args) {
+        const eintrag = await this.mcpEintragFinden(args.name);
+        const harness = await this.harnessGeprueft(args.ziel.harness);
+        const faehig = this.harnessMitMcp(harness.name);
+        if (!faehig.mcp.ebenen().includes(args.ziel.ort.art))
+            throw new McpEbeneNichtUnterstuetzt(harness.name, args.ziel.ort.art);
+        await faehig.mcp.einhaengen(eintrag.name, eintrag.konfig, args.ziel.ort);
+        const warnung = await this.mcpVariablenWarnung(faehig, eintrag, args.ziel.ort);
+        const hinweis = faehig.mcp.hinweisNachAenderung?.();
+        return {
+            eintrag,
+            ziel: args.ziel,
+            ...(hinweis === undefined ? {} : { hinweis }),
+            ...(warnung === undefined ? {} : { warnung }),
+        };
+    }
+    /** MCP aushängen (E61): Gegenstück zu `mcpEinhaengen`, ohne F39-Prüfung. */
+    async mcpAushaengen(args) {
+        const eintrag = await this.mcpEintragFinden(args.name);
+        const harness = await this.harnessGeprueft(args.ziel.harness);
+        const faehig = this.harnessMitMcp(harness.name);
+        if (!faehig.mcp.ebenen().includes(args.ziel.ort.art))
+            throw new McpEbeneNichtUnterstuetzt(harness.name, args.ziel.ort.art);
+        await faehig.mcp.aushaengen(eintrag.name, args.ziel.ort);
+        const hinweis = faehig.mcp.hinweisNachAenderung?.();
+        return { eintrag, ziel: args.ziel, ...(hinweis === undefined ? {} : { hinweis }) };
+    }
+    /**
+     * MCP übernehmen (E64, F48=O2): einen Eintrag aus der geteilten Konfigurationsdatei eines Ortes
+     * (bei Claude Code die `.mcp.json` der Projektwurzel) in den privaten Bereich desselben Ortes
+     * holen — eintragen und aus der geteilten Datei entfernen. Der Konfigblock kommt 1:1 aus der
+     * Datei, nicht aus dem Katalog: es gibt Einträge, die der Katalog nicht kennt, und beide Sorten
+     * müssen gehen. Die Fähigkeit hängt am Adapter (E16), nicht am Namen: fehlt sie, kennt dieser
+     * Harness-Typ keine geteilte Datei.
+     */
+    async mcpUebernehmen(args) {
+        const harness = await this.harnessGeprueft(args.ziel.harness);
+        const faehig = this.harnessMitMcp(harness.name);
+        const uebernehmen = faehig.mcp.geteiltenUebernehmen;
+        if (uebernehmen === undefined)
+            throw new McpUebernahmeNichtMoeglich(args.ziel);
+        const { datei } = await uebernehmen.call(faehig.mcp, args.name, args.ziel.ort);
+        const hinweis = faehig.mcp.hinweisNachAenderung?.();
+        return { name: args.name, ziel: args.ziel, datei, ...(hinweis === undefined ? {} : { hinweis }) };
+    }
+    /**
+     * Alle Orte, an denen MCP-Server grundsätzlich hängen können (E61): je Harness mit der Fähigkeit
+     * (E16, am Adapter abgefragt, nie am Namen) seine Ebenen aufgelöst zu tatsächlichen Zielen — Home,
+     * jedes bekannte Profil, jedes bekannte Arbeitsverzeichnis. Unabhängig davon, ob dort schon etwas
+     * hängt oder der Harness gerade aktiv ist (E38): das entscheidet der Aufrufer. Geteilt zwischen
+     * `mcpUebersicht` (dort mit `eingehaengte` abgeglichen) und `mcpPlaetze` (roh für den
+     * Einhängen-Dialog der GUI).
+     */
+    async mcpZiele() {
+        const ziele = [];
+        const zustand = await this.p.zustand.lesen();
+        for (const harness of await this.vorhandeneHarnesses()) {
+            if (!kannMcp(harness))
+                continue;
+            const ebenen = harness.mcp.ebenen();
+            if (ebenen.includes('home'))
+                ziele.push({ harness: harness.name, ort: { art: 'home' } });
+            if (ebenen.includes('profil') && kannProfile(harness))
+                for (const name of await harness.profile())
+                    ziele.push({ harness: harness.name, ort: { art: 'profil', name } });
+            if (ebenen.includes('arbeitsverzeichnis'))
+                for (const pfad of zustand.arbeitsverzeichnisse)
+                    ziele.push(arbeitsverzeichnisZiel(harness.name, pfad));
+        }
+        return ziele;
+    }
+    /**
+     * Die Plätze für den Einhängen-Dialog der GUI (E61-Folgerunde, F42): dieselbe Liste wie in
+     * `mcpUebersicht`, aber roh, ohne den Abgleich mit Katalog-Einträgen. Die Fähigkeit hängt am
+     * Adapter, nicht am Harness-Namen (E16): agents kommt nie vor, weil es `mcp` nicht implementiert.
+     */
+    async mcpPlaetze() {
+        return this.mcpZiele();
+    }
+    /**
+     * Übersicht für `hmgr mcp list` (E61): je Katalog-Eintrag, wo er eingehängt ist, dazu Einträge in
+     * Harness-Konfigurationen, die nicht im Katalog stehen (nur genannt, nicht angefasst).
+     */
+    async mcpUebersicht() {
+        const katalog = (await this.p.mcpKatalog.lesen()).map((eintrag) => ({
+            eintrag,
+            eingehaengt: [],
+            geteilteFundorte: [],
+        }));
+        const nachName = new Map(katalog.map((k) => [k.eintrag.name, k]));
+        const unbekannt = [];
+        const unbekannteGeteilteFundorte = [];
+        for (const ziel of await this.mcpZiele()) {
+            const faehig = this.harnessMitMcp(ziel.harness);
+            const namen = await faehig.mcp.eingehaengte(ziel.ort).catch(() => []);
+            for (const mcpName of namen) {
+                const eintrag = nachName.get(mcpName);
+                if (eintrag !== undefined)
+                    eintrag.eingehaengt.push(ziel);
+                else
+                    unbekannt.push({ ziel, name: mcpName });
+            }
+            const geteilt = (await faehig.mcp.geteilteFundorte?.(ziel.ort).catch(() => [])) ?? [];
+            for (const fundort of geteilt) {
+                const eintrag = nachName.get(fundort.name);
+                if (eintrag !== undefined)
+                    eintrag.geteilteFundorte.push({ ziel, datei: fundort.datei, scope: fundort.scope });
+                else
+                    unbekannteGeteilteFundorte.push({ ziel, name: fundort.name, datei: fundort.datei, scope: fundort.scope });
+            }
+        }
+        return { katalog, unbekannt, unbekannteGeteilteFundorte };
+    }
+    /**
+     * Säubern (E38): entfernt in allen Zielen dieses Harness-Typs (Home, Profile, bekannte
+     * Arbeitsverzeichnisse) die von hmgr angelegten Links und baut harness-eigene Einträge zurück, die
+     * hmgr angelegt hat (etwa Hermes' external_dirs-Eintrag). Fremde Einträge bleiben liegen. Läuft
+     * unabhängig davon, ob der Harness aktiv ist oder auf dem Rechner liegt, damit auch eine
+     * Deinstallation sauber aufgeräumt werden kann.
+     */
+    async saeubern(harnessName) {
+        const harness = this.harness(harnessName); // wirft HarnessTypUnbekannt bei unbekanntem Namen
+        const zustand = await this.p.zustand.lesen();
+        const ziele = [];
+        if (harness.orte().includes('home'))
+            ziele.push({ harness: harness.name, ort: { art: 'home' } });
+        if (harness.orte().includes('profil') && kannProfile(harness))
+            for (const name of await harness.profile())
+                ziele.push({ harness: harness.name, ort: { art: 'profil', name } });
+        if (harness.orte().includes('arbeitsverzeichnis'))
+            for (const pfad of zustand.arbeitsverzeichnisse)
+                ziele.push(arbeitsverzeichnisZiel(harness.name, pfad));
+        const zielErgebnisse = [];
+        for (const ziel of ziele) {
+            const verzeichnis = harness.zielVerzeichnis(ziel.ort);
+            const eintraege = await this.p.ziele.eintraege(ziel, verzeichnis).catch(() => []);
+            const entfernteLinks = [];
+            for (const eintrag of eintraege) {
+                if (eintrag.art === 'fremd')
+                    continue; // fremde Einträge bleiben liegen
+                const name = eintrag.art === 'link' ? eintrag.link.name : eintrag.name;
+                await this.p.ziele.linkEntfernen(ziel, verzeichnis, name);
+                entfernteLinks.push(name);
+            }
+            const konfigurationZurueckgebaut = kannZurueckbauen(harness) ? await harness.zurueckbauen(ziel.ort) : false;
+            zielErgebnisse.push({ ziel, entfernteLinks, konfigurationZurueckgebaut });
+        }
+        return { harness: harness.name, ziele: zielErgebnisse };
+    }
     /**
      * Quelle hinzufügen: prüft, dass sie erreichbar ist, und liest Skills und Marketplace (E24).
      * Steht dieselbe Quelle schon in einer anderen Schreibweise im Zustand, kommt keine zweite dazu
      * (E36). Gelesen wird dann unter der Schreibweise, unter der sie geführt wird, denn mit ihr ist
      * der Basis-Clone angelegt. `bekannt` sagt, ob es so kam, `quelle` nennt die geführte Fassung.
+     *
+     * Anzeigename (E59): ohne `name` wird der abgeleitete Name gespeichert. Namen sind eindeutig,
+     * eine andere geführte Quelle mit demselben Anzeigenamen ist ein Fehler (`QuelleNameBelegt`).
+     * Bei einer schon bekannten Quelle wird ihr Name nicht überschrieben, `name` bleibt ohne Wirkung.
      */
-    async quelleHinzufuegen(quelle) {
+    async quelleHinzufuegen(quelle, name) {
         const zustand = await this.p.zustand.lesen();
         const key = quelleSchluessel(quelle);
         const gefuehrt = zustand.quellen.find((q) => quelleSchluessel(q) === key);
-        const wirksam = gefuehrt ?? quelle;
-        const ref = await this.p.quellen.standardRef(wirksam);
-        const skills = await this.p.quellen.skills(wirksam, ref);
-        const marketplace = await this.p.quellen.marketplace(wirksam, ref);
-        if (gefuehrt === undefined) {
-            zustand.quellen.push(quelle);
-            await this.p.zustand.schreiben(zustand);
+        if (gefuehrt !== undefined) {
+            const ref = await this.p.quellen.standardRef(gefuehrt);
+            const skills = await this.p.quellen.skills(gefuehrt, ref);
+            const marketplace = await this.p.quellen.marketplace(gefuehrt, ref);
+            return { quelle: gefuehrt, skills, marketplace, bekannt: true };
+        }
+        const angefragterName = name?.trim();
+        const effektiverName = angefragterName !== undefined && angefragterName.length > 0 ? angefragterName : quelleNameAbleiten(quelle);
+        const kollision = zustand.quellen.find((q) => quelleName(q) === effektiverName);
+        if (kollision !== undefined)
+            throw new QuelleNameBelegt(effektiverName, kollision);
+        const neu = { ...quelle, name: effektiverName };
+        const ref = await this.p.quellen.standardRef(neu);
+        const skills = await this.p.quellen.skills(neu, ref);
+        const marketplace = await this.p.quellen.marketplace(neu, ref);
+        zustand.quellen.push(neu);
+        await this.p.zustand.schreiben(zustand);
+        return { quelle: neu, skills, marketplace, bekannt: false };
+    }
+    /**
+     * Quelle umbenennen (E59): ändert nur den Anzeigenamen, die Identität bleibt `quelleSchluessel`
+     * (E36). Referenz über URL/Pfad wie `quelleEntfernen`, eine unbekannte Quelle ist ein Fehler.
+     * Namen sind eindeutig, eine Kollision mit einer anderen geführten Quelle bricht ab, ohne zu
+     * schreiben. Gibt die geführte Quelle mit dem neuen Namen zurück.
+     */
+    async quelleUmbenennen(quelle, name) {
+        const zustand = await this.p.zustand.lesen();
+        const key = quelleSchluessel(quelle);
+        const gefuehrt = zustand.quellen.find((q) => quelleSchluessel(q) === key);
+        if (gefuehrt === undefined)
+            throw new QuelleUnbekannt(quelle);
+        const neuerName = name.trim();
+        // Ein leerer Name wäre kein Name: `quelleName` fiele still auf den abgeleiteten zurück, an der
+        // Eindeutigkeitsprüfung vorbei. Lieber ein Fehler als zwei Quellen mit derselben Anzeige.
+        if (neuerName.length === 0)
+            throw new Error('Der Anzeigename darf nicht leer sein.');
+        const kollision = zustand.quellen.find((q) => quelleSchluessel(q) !== key && quelleName(q) === neuerName);
+        if (kollision !== undefined)
+            throw new QuelleNameBelegt(neuerName, kollision);
+        const umbenannt = { ...gefuehrt, name: neuerName };
+        zustand.quellen = zustand.quellen.map((q) => (quelleSchluessel(q) === key ? umbenannt : q));
+        await this.p.zustand.schreiben(zustand);
+        return umbenannt;
+    }
+    /**
+     * Quelle entfernen: reines Vergessen aus dem Zustand (E54), wie beim Arbeitsverzeichnis (E52).
+     * Checkouts und Links bleiben liegen, bestehende Links gelten danach als „Link ohne Quelle"
+     * (das erkennt der Dateisystem-Adapter von selbst). Identität über `quelleSchluessel` (E36); eine
+     * unbekannte Quelle ist ein Fehler. Gibt die geführte Fassung zurück, für eine Meldung, die dieselbe
+     * Schreibweise nennt wie source list, auch wenn der Aufruf eine andere Schreibweise genannt hat.
+     */
+    async quelleEntfernen(quelle) {
+        const zustand = await this.p.zustand.lesen();
+        const key = quelleSchluessel(quelle);
+        const gefuehrt = zustand.quellen.find((q) => quelleSchluessel(q) === key);
+        if (gefuehrt === undefined)
+            throw new QuelleUnbekannt(quelle);
+        zustand.quellen = zustand.quellen.filter((q) => quelleSchluessel(q) !== key);
+        await this.p.zustand.schreiben(zustand);
+        return gefuehrt;
+    }
+    /**
+     * Inventar einer Quelle für das Aufräum-Angebot nach dem Entfernen (E58): alle von hmgr gelegten
+     * Links über alle Ziele (auch die, die ein Plugin für Harnesses ohne Plugin-Fähigkeit aufgelöst
+     * hat, sie stehen als gewöhnliche Links da), alle Checkouts der Quelle, dazu nur zum Nennen:
+     * installierte Plugins aus ihrem Marketplace und Zeiger, die sie führen. Muss VOR `quelleEntfernen`
+     * laufen: danach gelten ihre Links nur noch als „Link ohne Quelle" und die Zuordnung ist weg.
+     */
+    async quelleAufraeumInventar(quelle) {
+        const key = quelleSchluessel(quelle);
+        const zustand = await this.p.zustand.lesen();
+        const marktplatz = await this.marketplaceLesen(quelle).catch(() => null);
+        const links = [];
+        const plugins = new Set();
+        for (const zielZustand of await this.istZustand()) {
+            for (const eintrag of zielZustand.eintraege) {
+                if (eintrag.art !== 'link')
+                    continue;
+                if (quelleSchluessel(eintrag.link.checkout.quelle) !== key)
+                    continue;
+                links.push({ ziel: zielZustand.ziel, verzeichnis: zielZustand.verzeichnis, name: eintrag.link.name });
+            }
+            if (marktplatz === null || zielZustand.plugins === undefined)
+                continue;
+            for (const eintrag of zielZustand.plugins) {
+                if (pluginSchluesselZerlegen(eintrag).marketplace === marktplatz.name)
+                    plugins.add(eintrag);
+            }
         }
-        return { quelle: wirksam, skills, marketplace, bekannt: gefuehrt !== undefined };
+        const checkouts = (await this.p.quellen.checkouts()).filter((c) => quelleSchluessel(c.quelle) === key);
+        // Lokale Änderungen (E15, F31a): vorher erhoben, damit quelleAufraeumen VOR der ersten Löschung
+        // prüfen kann, statt einen Checkout mittendrin scheitern zu lassen.
+        const checkoutsMitLokalenAenderungen = [];
+        for (const checkout of checkouts) {
+            if (await this.p.quellen.lokaleAenderungen(checkout))
+                checkoutsMitLokalenAenderungen.push(checkout);
+        }
+        // Zeiger-Einträge (E57): nur zählen/nennen, welche Bindungen die Quelle in ihrem Zeiger führen.
+        const zeigerPfade = new Set();
+        for (const bindung of zustand.bindungen) {
+            const zeiger = await this.p.zeiger.lesen(bindung.zeigerPfad).catch(() => undefined);
+            if (zeiger !== undefined && zeiger.quellen.some((q) => quelleSchluessel(q) === key))
+                zeigerPfade.add(bindung.zeigerPfad);
+        }
+        return { quelle, links, checkouts, checkoutsMitLokalenAenderungen, plugins: [...plugins], zeigerPfade: [...zeigerPfade] };
+    }
+    /**
+     * Räumt das zuvor mit `quelleAufraeumInventar` erhobene Inventar ab (E58): jeden Link direkt über
+     * den Ziele-Port entfernen, nicht über den Anwendungsfall `linkEntfernen` (der Zeiger-Arbeit macht
+     * bzw. jetzt E57 würfe), danach jeden Checkout von der Platte nehmen. Zeiger und Plugins bleiben
+     * unangetastet (E57, E58): sie waren im Inventar nur genannt. Hat ein Checkout lokale Änderungen
+     * (E15), bricht der Aufruf VOR der ersten Löschung mit `QuelleAufraeumenLokaleAenderungen` ab,
+     * kein stilles Teil-Überspringen (F31a).
+     */
+    async quelleAufraeumen(inventar) {
+        if (inventar.checkoutsMitLokalenAenderungen.length > 0)
+            throw new QuelleAufraeumenLokaleAenderungen(inventar.checkoutsMitLokalenAenderungen);
+        for (const link of inventar.links)
+            await this.p.ziele.linkEntfernen(link.ziel, link.verzeichnis, link.name);
+        for (const checkout of inventar.checkouts)
+            await this.p.quellen.entfernen(checkout);
+        return { entfernteLinks: inventar.links.length, entfernteCheckouts: inventar.checkouts.length };
     }
     /** Marketplace einer Quelle am Standard-Ref, mit den Plugins als Modellwerte. */
     async marketplaceLesen(quelle) {
@@ -105,6 +534,31 @@ export class Anwendungsfaelle {
             })),
         };
     }
+    /** Die bekannten Quellen, ohne sie zu lesen. Für Listen, die nur die Herkunft nennen. */
+    async quellen() {
+        return (await this.p.zustand.lesen()).quellen;
+    }
+    /**
+     * Skill-Katalog aller bekannten Quellen (E40 R3): je Quelle ihre Skills, mit `beschreibung`, wo
+     * vorhanden (E39). Für einen künftigen CLI-Weg (etwa `hmgr skill list`) gedacht, heute schon von
+     * der GUI benutzt. Eine nicht erreichbare Quelle bekommt einen Fehlervermerk statt den Lauf
+     * abzubrechen, wie bei `istZustand` und `marketplaces`.
+     */
+    async katalog() {
+        const zustand = await this.p.zustand.lesen();
+        const ergebnis = [];
+        for (const quelle of zustand.quellen) {
+            try {
+                const ref = await this.p.quellen.standardRef(quelle);
+                const skills = await this.p.quellen.skills(quelle, ref);
+                ergebnis.push({ quelle, ref, skills });
+            }
+            catch (fehler) {
+                ergebnis.push({ quelle, skills: [], fehler: fehlertext(fehler) });
+            }
+        }
+        return ergebnis;
+    }
     /** Alle Marketplaces der bekannten Quellen, für `hmgr plugin list`. */
     async marketplaces() {
         const zustand = await this.p.zustand.lesen();
@@ -207,7 +661,7 @@ export class Anwendungsfaelle {
             zustand.arbeitsverzeichnisse.push(verzeichnis);
         if (zeigerPfad !== undefined) {
             const gebunden = zeigerPfad;
-            for (const harness of await this.vorhandeneHarnesses()) {
+            for (const harness of await this.vorhandeneAktiveHarnesses()) {
                 if (!harness.orte().includes('arbeitsverzeichnis'))
                     continue;
                 const ziel = arbeitsverzeichnisZiel(harness.name, verzeichnis);
@@ -256,6 +710,19 @@ export class Anwendungsfaelle {
         const zustand = await this.p.zustand.lesen();
         return zustand.bindungen.find((b) => zielSchluessel(b.ziel) === schluessel)?.zeigerPfad;
     }
+    /**
+     * Wächter vor jeder Wirkung, die ohne `--local` tatsächlich in einen Zeiger schreiben würde
+     * (E57): Ziel ist ein Arbeitsverzeichnis, dafür existiert eine Bindung, und `lokal` ist nicht
+     * gesetzt. Dann wirft er `ZeigerSchreibenGesperrt`, bevor irgendein Link gelegt, entfernt oder
+     * ein Plugin installiert bzw. deinstalliert wird, also nie eine halbe Wirkung. Ohne Bindung oder
+     * mit `lokal: true` bleibt das Verhalten unverändert (E26).
+     */
+    async zeigerSchreibenPruefen(ziel, lokal) {
+        if (lokal === true || ziel.ort.art !== 'arbeitsverzeichnis')
+            return;
+        if ((await this.bindungFinden(ziel)) !== undefined)
+            throw new ZeigerSchreibenGesperrt(ziel);
+    }
     /** Skill über alle Quellen suchen. Mehrere Treffer sind nur mit Quellenhinweis erlaubt. */
     async skillFinden(name, quelleHinweis) {
         const zustand = await this.p.zustand.lesen();
@@ -323,6 +790,9 @@ export class Anwendungsfaelle {
         const zeigerPfad = await this.bindungFinden(args.ziel);
         if (zeigerPfad === undefined)
             throw new EinschraenkungOhneZeiger(args.ziel, version);
+        // Eine Versionseinschränkung schreibt immer geteilt (siehe EinschraenkungOhneZeiger oben), das
+        // trifft die Sperre also ausnahmslos, solange sie steht (E57).
+        await this.zeigerSchreibenPruefen(args.ziel, args.lokal);
         const fund = await this.fundAusZeiger(args.skill, version, args.quelle);
         const link = await this.linkAnlegen(harness, args.ziel, fund, args.ersetzen);
         await this.zeigerErgaenzen(zeigerPfad, fund, version);
@@ -331,6 +801,8 @@ export class Anwendungsfaelle {
     }
     /** Link legen, wenn Quelle, Ref und Skill schon feststehen. Die Zeiger-Arbeit ist dieselbe. */
     async linkAusFund(harness, ziel, fund, ersetzen, lokal) {
+        // Vor jeder Wirkung: kein Link, wenn danach das Schreiben in den Zeiger scheitern würde (E57).
+        await this.zeigerSchreibenPruefen(ziel, lokal);
         const link = await this.linkAnlegen(harness, ziel, fund, ersetzen);
         const hinweise = [];
         if (lokal !== true && ziel.ort.art === 'arbeitsverzeichnis') {
@@ -341,6 +813,12 @@ export class Anwendungsfaelle {
             else
                 await this.zeigerErgaenzen(zeigerPfad, fund);
         }
+        else if (lokal === true && ziel.ort.art === 'arbeitsverzeichnis' && (await this.bindungFinden(ziel)) !== undefined) {
+            // Zeiger-Bindung vorhanden, aber ausdrücklich lokal (E57, F32): der Zeiger bleibt unangetastet,
+            // ein Hinweis sagt das, damit es niemand für einen geteilten Link hält. Ohne Skill-Namen, damit
+            // die GUI ihn nach einem Lauf über mehrere Skills einmal statt N-mal zeigen kann.
+            hinweise.push('Der Link liegt nur lokal, der Zeiger bleibt unangetastet (F32).');
+        }
         const vomHarness = await this.harnessHinweis(harness, ziel.ort);
         if (vomHarness !== undefined)
             hinweise.push(vomHarness);
@@ -368,19 +846,68 @@ export class Anwendungsfaelle {
             this.beantwortet.set(schluessel, hinweis);
         return hinweis;
     }
-    /** Link entfernen. Ohne `lokal` verschwindet der Skill auch aus dem Zeiger (E17). */
+    /**
+     * Link entfernen. Ohne `lokal` verschwindet der Skill auch aus dem Zeiger (E17). Mit `lokal` an
+     * einem gebundenen Ziel bleibt der Zeiger unangetastet, ein Hinweis sagt das (E57, F32).
+     */
     async linkEntfernen(args) {
         const harness = await this.harnessGeprueft(args.ziel.harness);
+        // Vor jeder Wirkung: kein Entfernen, wenn danach das Schreiben in den Zeiger scheitern würde (E57).
+        await this.zeigerSchreibenPruefen(args.ziel, args.lokal);
         await this.p.ziele.linkEntfernen(args.ziel, harness.zielVerzeichnis(args.ziel.ort), args.skill);
+        if (args.lokal === true && args.ziel.ort.art === 'arbeitsverzeichnis') {
+            const zeigerPfad = await this.bindungFinden(args.ziel);
+            if (zeigerPfad !== undefined)
+                return { hinweis: 'Der Link ist nur lokal entfernt, der Zeiger bleibt unangetastet (F32).' };
+            return {};
+        }
         if (args.lokal === true || args.ziel.ort.art !== 'arbeitsverzeichnis')
-            return;
+            return {};
         const zeigerPfad = await this.bindungFinden(args.ziel);
         if (zeigerPfad === undefined)
-            return;
+            return {};
         const zeiger = await this.p.zeiger.lesen(zeigerPfad);
         if (!zeiger.skills.delete(args.skill))
-            return;
+            return {};
         await this.p.zeiger.schreiben(zeigerPfad, zeiger);
+        return {};
+    }
+    /**
+     * Ignoriert einen fremden Eintrag (E43): idempotent, kein Duplikat. Gleichheit über harness, Ort
+     * (strukturell, über `zielSchluessel`) und Name.
+     */
+    async eintragIgnorieren(args) {
+        const zustand = await this.p.zustand.lesen();
+        if (zustand.ignorierteEintraege.some((i) => ignorierterEintragGleich(i, args)))
+            return;
+        zustand.ignorierteEintraege.push({ harness: args.ziel.harness, ort: args.ziel.ort, name: args.name });
+        await this.p.zustand.schreiben(zustand);
+    }
+    /** Beachtet einen zuvor ignorierten Eintrag wieder: entfernt ihn aus der Ignorier-Liste (E43). */
+    async eintragBeachten(args) {
+        const zustand = await this.p.zustand.lesen();
+        const vorher = zustand.ignorierteEintraege.length;
+        zustand.ignorierteEintraege = zustand.ignorierteEintraege.filter((i) => !ignorierterEintragGleich(i, args));
+        if (zustand.ignorierteEintraege.length === vorher)
+            return;
+        await this.p.zustand.schreiben(zustand);
+    }
+    /**
+     * Löscht einen fremden Eintrag vom Ziel auf der Platte (E46): ein Verzeichnis rekursiv, einen
+     * fremden Symlink als Link, ohne ihm zu folgen, die Arbeitskopie dahinter bleibt unangetastet.
+     * Nur Einträge der Art 'fremd', ein hmgr-eigener Link ist ein Fehler, dafür gibt es
+     * `linkEntfernen`. Ein nicht vorhandener Eintrag ist ebenso ein Fehler. War der Eintrag ignoriert
+     * (E43), wird die Marke mitentfernt, sie zeigte sonst auf Gelöschtes.
+     */
+    async eintragLoeschen(args) {
+        const harness = await this.harnessGeprueft(args.ziel.harness);
+        const verzeichnis = harness.zielVerzeichnis(args.ziel.ort);
+        const eintraege = await this.p.ziele.eintraege(args.ziel, verzeichnis);
+        const eintrag = eintraege.find((e) => (e.art === 'link' ? e.link.name : e.name) === args.name);
+        if (eintrag === undefined || eintrag.art !== 'fremd')
+            throw new FremderEintragUnbekannt(args.ziel, args.name);
+        await this.p.ziele.eintragLoeschen(args.ziel, verzeichnis, args.name);
+        await this.eintragBeachten({ ziel: args.ziel, name: args.name });
     }
     /**
      * Plugin an einem Ziel herstellen: mit Plugin-Fähigkeit über die CLI des Harness, sonst als
@@ -416,6 +943,8 @@ export class Anwendungsfaelle {
     async pluginLegen(args) {
         const harness = await this.harnessGeprueft(args.ziel.harness);
         const fund = await this.pluginFinden(args.plugin, args.quelle);
+        // Vor jeder Wirkung: kein Plugin, wenn danach das Schreiben in den Zeiger scheitern würde (E57).
+        await this.zeigerSchreibenPruefen(args.ziel, args.lokal);
         const ergebnis = await this.pluginHerstellen(harness, args.ziel, fund);
         if (args.lokal === true || args.ziel.ort.art !== 'arbeitsverzeichnis')
             return ergebnis;
@@ -466,6 +995,8 @@ export class Anwendungsfaelle {
     async pluginEntfernen(args) {
         const harness = await this.harnessGeprueft(args.ziel.harness);
         const fund = await this.pluginFinden(args.plugin);
+        // Vor jeder Wirkung: kein Entfernen, wenn danach das Schreiben in den Zeiger scheitern würde (E57).
+        await this.zeigerSchreibenPruefen(args.ziel, args.lokal);
         const schluessel = pluginSchluessel(fund.plugin);
         const entfernt = [];
         if (kannPlugins(harness)) {
@@ -567,7 +1098,7 @@ export class Anwendungsfaelle {
             return ergebnis;
         }
         ergebnis.zeigerPfad = zeigerPfad;
-        const harnesses = (await this.vorhandeneHarnesses()).filter((h) => h.orte().includes('arbeitsverzeichnis'));
+        const harnesses = (await this.vorhandeneAktiveHarnesses()).filter((h) => h.orte().includes('arbeitsverzeichnis'));
         if (harnesses.length === 0) {
             ergebnis.hinweise.push('Kein Harness auf diesem Rechner, nichts zu tun (E20).');
             return ergebnis;
@@ -660,11 +1191,28 @@ export class Anwendungsfaelle {
      * Aktualisieren (E14, E15): jeden Checkout unter der Wurzel auf den Stand seines Refs bringen.
      * Lokale Quellen haben keinen Checkout und bleiben unberührt (B11). Links zeigen auf die
      * Worktree-Pfade, die dabei stehen bleiben, also müssen sie nicht erneuert werden.
+     *
+     * Checkouts, deren Quelle der Zustand nicht führt, bleiben ganz außen vor (E54): sie werden weder
+     * geholt noch als verwaist zum Löschen angeboten. Eine vergessene Quelle ist vergessen, ihre
+     * Checkouts und Links liegen unangetastet, bis die Quelle wieder hinzukommt.
      */
-    async aktualisieren() {
+    async aktualisieren(args) {
+        const rueckfragen = args?.rueckfragen ?? true;
+        const bekannt = new Map((await this.p.zustand.lesen()).quellen.map((q) => [quelleSchluessel(q), q]));
         const checkouts = [];
-        for (const checkout of await this.p.quellen.checkouts())
-            checkouts.push({ checkout, aktualisierung: await this.p.quellen.aktualisieren(checkout) });
+        for (const checkout of await this.p.quellen.checkouts()) {
+            const gefuehrt = bekannt.get(quelleSchluessel(checkout.quelle));
+            if (gefuehrt === undefined)
+                continue;
+            const aktualisierung = await this.p.quellen.aktualisieren(checkout);
+            // Der Quellen-Port baut Checkouts von der Platte (remote.origin.url), ohne den Zustand zu
+            // befragen: der Anzeigename fehlt dort. Für den Bericht kommt er aus der geführten Quelle
+            // (E59), sonst zeigte eine umbenannte Quelle hier wieder ihren abgeleiteten Namen.
+            checkouts.push({
+                checkout: { ...checkout, quelle: quelleMitNamen(checkout.quelle, gefuehrt.name) },
+                aktualisierung,
+            });
+        }
         // Nach den Checkouts die Plugins nachziehen (E14).
         const pluginHarnesses = [];
         for (const harness of await this.vorhandeneHarnesses()) {
@@ -673,7 +1221,7 @@ export class Anwendungsfaelle {
             await harness.plugins.aktualisieren();
             pluginHarnesses.push(harness.name);
         }
-        return { checkouts, pluginHarnesses, aufraeumen: await this.verwaisteAufraeumen(checkouts) };
+        return { checkouts, pluginHarnesses, aufraeumen: await this.verwaisteAufraeumen(checkouts, rueckfragen) };
     }
     /**
      * Pfade, in die ein Link zeigt. Gelesen wird wie beim Ist-Zustand (E19): die Ziele der
@@ -697,8 +1245,11 @@ export class Anwendungsfaelle {
      * mit lokaler Änderung bleibt liegen und wird nur gemeldet (E15), er kommt gar nicht erst in die
      * Frage. Gefragt wird einmal für alle Kandidaten (E28); wo niemand antwortet, gilt Nein und es
      * wird nichts gelöscht.
+     *
+     * Bei `rueckfragen: false` (E44, automatischer GUI-Lauf) werden Verwaiste wie sonst ermittelt und
+     * gemeldet, aber weder gefragt noch gelöscht.
      */
-    async verwaisteAufraeumen(checkouts) {
+    async verwaisteAufraeumen(checkouts, rueckfragen) {
         const belegt = await this.belegteCheckoutPfade();
         const verwaiste = [];
         for (const { checkout, aktualisierung } of checkouts) {
@@ -708,6 +1259,8 @@ export class Anwendungsfaelle {
             const lokaleAenderung = aktualisierung.ergebnis === 'uebersprungen';
             verwaiste.push({ checkout, lokaleAenderung, geloescht: false });
         }
+        if (!rueckfragen)
+            return { verwaiste, gefragt: false };
         const kandidaten = verwaiste.filter((v) => !v.lokaleAenderung);
         if (kandidaten.length === 0)
             return { verwaiste, gefragt: false };
@@ -720,14 +1273,124 @@ export class Anwendungsfaelle {
         return { verwaiste, gefragt: true };
     }
     /**
-     * Übernahme (B12, E31): fremde Symlinks eines Ziels durch eigene Links auf einen hmgr-Checkout
-     * derselben Quelle am selben Ref ersetzen. Die Arbeitskopie bleibt unberührt und wird nicht als
-     * Quelle registriert, das ist B11. Ein Eintrag, der nicht auflösbar ist, bleibt liegen und wird
-     * gemeldet, damit ein Lauf über viele Einträge nicht an einem einzelnen abbricht.
+     * Erkennungskette eines fremden Eintrags (E31, E48), rein lesend, ohne etwas zu verändern. Sie
+     * bedient Prognose (`istZustand`) und Übernahme gleichermaßen:
+     * - Ein Symlink führt in eine Arbeitskopie (B12): Quelle und Ref aus `remote.origin.url` und dem
+     *   ausgecheckten Branch, der Skill über den relativen Pfad in der Quelle.
+     * - Sonst gilt ein Ordner mit eigenem `.git` an Ort und Stelle als Arbeitskopie (E48 a): erkannt
+     *   nur, wenn sie sauber ist und ihr HEAD im lokalen Stand des Remote-Branchs enthalten ist,
+     *   sonst „lokale-aenderungen". Erkannt daran, dass `arbeitskopie` auf den Eintrag selbst
+     *   angewandt dessen eigene Wurzel liefert (`relativerPfad === ''`).
+     * - Sonst greift bei einem agents-Ziel das Lockfile der skills-CLI (E48 b, HARNESS-FAKTEN):
+     *   `sourceUrl` und `ref` liefern die Quelle, ersetzt wird nur, wenn der Ordnerinhalt dem
+     *   festgehaltenen `skillFolderHash` entspricht. Das Hash-Verfahren der skills-CLI ist nur für
+     *   Nicht-GitHub-Quellen als SHA-256 über Dateien reproduzierbar (`computeSkillFolderHash`);
+     *   für GitHub-Quellen benutzt sie eine Baum-SHA aus der GitHub-API (40 Zeichen statt 64), die
+     *   sich ohne Netzzugriff nicht nachbilden lässt. Ein `skillFolderHash` mit 40 Zeichen ergibt
+     *   deshalb ehrlich „nicht-pruefbar" statt fälschlich „lokale-aenderungen" (E50); nur ein
+     *   nachrechenbarer (64-stelliger) Hash, der abweicht, ergibt „lokale-aenderungen".
+     * - Sonst „kein-link": nichts davon trifft zu.
+     * Ein kaputter Teil (unlesbares Lockfile, Git-Fehler) bricht die Erhebung nie ab, er ergibt einen
+     * Grund. `bekannt` normalisiert die erkannte Quelle auf die schon geführte Schreibweise (E36),
+     * ohne sie selbst zu verändern.
      *
-     * `probelauf` schreibt weder Zustand noch Checkout noch Link. Die Skill-Liste der Quelle wird
-     * trotzdem gelesen, sonst wäre der Grund „skill-unbekannt" nicht zu haben. Der Git-Adapter legt
-     * dabei den Basis-Clone der Quelle an, das Ziel und der Zustand bleiben unangetastet.
+     * `nurLesend` trennt Prognose von Übernahme an genau einer Stelle: der Skill-Katalog einer
+     * Quelle, die hmgr noch nicht führt, bleibt ungefragt. `skills()` legte sonst deren Basis-Clone
+     * an, und die Erhebung würde für jeden fremden Symlink ein fremdes Repo aus dem Netz holen und
+     * auf die Platte schreiben. Bekannte Quellen haben ihren Clone schon, sie werden wie bisher
+     * gefragt. Die Prognose nennt dann Quelle und Ref ohne Skill (E48), „skill-unbekannt" fällt in
+     * diesem Fall erst in der Vorschau der Übernahme auf.
+     */
+    async erkennenFremd(harness, verzeichnis, eintrag, bekannt, nurLesend) {
+        const unbekannt = (grund) => ({ art: 'unbekannt', grund });
+        const normalisiert = (kandidat) => bekannt.get(quelleSchluessel(kandidat)) ?? kandidat;
+        /** Skill aus dem Katalog: `null` heißt „nicht darin", `undefined` heißt „nicht gefragt". */
+        const ausKatalog = async (quelle, ref, pfad) => {
+            if (nurLesend && !bekannt.has(quelleSchluessel(quelle)))
+                return undefined;
+            const skills = await this.p.quellen.skills(quelle, ref).catch(() => []);
+            return skills.find((s) => s.pfad === pfad) ?? null;
+        };
+        if (eintrag.linkZiel !== undefined) {
+            const kopie = await this.p.quellen.arbeitskopie(eintrag.linkZiel).catch(() => null);
+            if (kopie === null)
+                return unbekannt('keine-arbeitskopie');
+            if (kopie.url === null)
+                return unbekannt('keine-url');
+            if (kopie.ref === null)
+                return unbekannt('kein-branch');
+            const quelle = normalisiert({ art: 'git', url: kopie.url });
+            const skill = await ausKatalog(quelle, kopie.ref, kopie.relativerPfad);
+            if (skill === null)
+                return unbekannt('skill-unbekannt');
+            return { art: 'erkannt', quelle, ref: kopie.ref, ...(skill === undefined ? {} : { skill }) };
+        }
+        const entryPfad = path.join(verzeichnis, eintrag.name);
+        // (a) Ordner mit eigenem .git an Ort und Stelle (E48).
+        const eigeneKopie = await this.p.quellen.arbeitskopie(entryPfad).catch(() => null);
+        if (eigeneKopie !== null && eigeneKopie.relativerPfad === '') {
+            if (eigeneKopie.url === null)
+                return unbekannt('keine-url');
+            if (eigeneKopie.ref === null)
+                return unbekannt('kein-branch');
+            const quelleRoh = { art: 'git', url: eigeneKopie.url };
+            const sauber = !(await this.p.quellen
+                .lokaleAenderungen({ quelle: quelleRoh, ref: eigeneKopie.ref, pfad: entryPfad })
+                .catch(() => true));
+            const enthalten = sauber && (await this.p.quellen.imRemoteEnthalten(entryPfad, eigeneKopie.ref).catch(() => false));
+            if (!enthalten)
+                return unbekannt('lokale-aenderungen');
+            const quelle = normalisiert(quelleRoh);
+            // Der Katalog (skills()) kennt einen Wurzel-Skill zwar seit dem E11-Nachtrag, aber er gilt
+            // für die geführte Quelle am gefragten Ref. Hier liegt eine fremde Arbeitskopie an Ort und
+            // Stelle: ihr Wurzel-Skill wird direkt von der Platte gelesen, ohne Clone (E48 a).
+            const skill = await this.p.quellen.wurzelSkill(entryPfad).catch(() => null);
+            if (skill === null)
+                return unbekannt('skill-unbekannt');
+            return { art: 'erkannt', quelle, ref: eigeneKopie.ref, skill };
+        }
+        // (b) Lockfile der skills-CLI, nur für agents-Ziele (E48 b).
+        if (harness.name === 'agents') {
+            const skillsHeim = harness.zielVerzeichnis({ art: 'home' });
+            const lockEintrag = await this.p.ziele
+                .skillLockEintrag(skillsHeim, eintrag.name)
+                .catch(() => undefined);
+            if (lockEintrag !== undefined) {
+                if (lockEintrag.ref === undefined)
+                    return unbekannt('kein-branch');
+                if (lockEintrag.skillPath === undefined)
+                    return unbekannt('skill-unbekannt');
+                // Eine GitHub-Baum-SHA (40 Hex-Zeichen) statt eines SHA-256 (64) lässt sich lokal nicht
+                // nachrechnen (E50): ehrlich „nicht prüfbar" statt fälschlich „lokale Änderungen".
+                if (lockEintrag.skillFolderHash.length === 40)
+                    return unbekannt('nicht-pruefbar');
+                const echterHash = await this.p.ziele.ordnerHash(verzeichnis, eintrag.name).catch(() => undefined);
+                if (echterHash === undefined || echterHash.toLowerCase() !== lockEintrag.skillFolderHash.toLowerCase())
+                    return unbekannt('lokale-aenderungen');
+                const quelle = normalisiert({ art: 'git', url: lockEintrag.sourceUrl });
+                const skill = await ausKatalog(quelle, lockEintrag.ref, skillPfadAusLock(lockEintrag.skillPath));
+                if (skill === null)
+                    return unbekannt('skill-unbekannt');
+                return { art: 'erkannt', quelle, ref: lockEintrag.ref, ...(skill === undefined ? {} : { skill }) };
+            }
+        }
+        return unbekannt('kein-link');
+    }
+    /**
+     * Übernahme (B12, E31): fremde Einträge eines Ziels durch eigene Links auf einen hmgr-Checkout
+     * derselben Quelle am selben Ref ersetzen. Eine Arbeitskopie, in die ein Symlink führt, bleibt
+     * unberührt und wird nicht als Quelle registriert, das ist B11. Ein Ordner mit eigenem `.git`
+     * oder ein Lockfile-Treffer wird dagegen selbst gelöscht und durch den Link ersetzt (E48 a/b). Ein
+     * Eintrag, der nicht auflösbar ist, bleibt liegen und wird gemeldet, damit ein Lauf über viele
+     * Einträge nicht an einem einzelnen abbricht.
+     *
+     * `probelauf` schreibt weder Zustand noch Checkout noch Link. Die Erkennungskette wird trotzdem
+     * gelesen, sonst wären die Gründe nicht zu haben. Der Git-Adapter legt dabei den Basis-Clone der
+     * Quelle an, das Ziel und der Zustand bleiben unangetastet.
+     *
+     * Mit `name` (E46) betrachtet der Lauf nur diesen einen fremden Eintrag, ohne `name` bleibt es
+     * bei allen fremden Einträgen des Ziels (CLI unverändert). Ein genannter Name, der am Ziel nicht
+     * als fremder Eintrag liegt, ist ein Fehler, gilt für Probelauf wie echten Lauf gleichermaßen.
      */
     async uebernehmen(args) {
         const harness = await this.harnessGeprueft(args.ziel.harness);
@@ -740,60 +1403,93 @@ export class Anwendungsfaelle {
         for (const q of (await this.p.zustand.lesen()).quellen)
             bekannt.set(quelleSchluessel(q), q);
         const eintraege = [];
-        for (const eintrag of await this.p.ziele.eintraege(args.ziel, verzeichnis)) {
+        const alleEintraege = await this.p.ziele.eintraege(args.ziel, verzeichnis);
+        if (args.name !== undefined) {
+            const gefunden = alleEintraege.find((e) => (e.art === 'link' ? e.link.name : e.name) === args.name);
+            if (gefunden === undefined || gefunden.art !== 'fremd')
+                throw new FremderEintragUnbekannt(args.ziel, args.name);
+        }
+        for (const eintrag of alleEintraege) {
             // Eigene Links sind schon fertig, sie kommen nicht in die Meldung.
             if (eintrag.art !== 'fremd')
                 continue;
             if (args.name !== undefined && eintrag.name !== args.name)
                 continue;
             const name = eintrag.name;
-            const liegenLassen = (grund) => void eintraege.push({ ergebnis: 'uebersprungen', name, grund });
-            if (eintrag.linkZiel === undefined) {
-                liegenLassen('kein-link');
-                continue;
-            }
-            const kopie = await this.p.quellen.arbeitskopie(eintrag.linkZiel);
-            if (kopie === null) {
-                liegenLassen('keine-arbeitskopie');
-                continue;
-            }
-            if (kopie.url === null) {
-                liegenLassen('keine-url');
-                continue;
-            }
-            // Ohne Branch gibt es keinen Ref, auf den ein Checkout zeigen könnte (detached HEAD).
-            if (kopie.ref === null) {
-                liegenLassen('kein-branch');
+            const prognose = await this.erkennenFremd(harness, verzeichnis, eintrag, bekannt, false);
+            if (prognose.art === 'unbekannt') {
+                eintraege.push({ ergebnis: 'uebersprungen', name, grund: prognose.grund });
                 continue;
             }
-            // Kennt hmgr das Repo schon in anderer Schreibweise, zählt die geführte Fassung (E36).
-            const gefuehrt = bekannt.get(quelleSchluessel({ art: 'git', url: kopie.url }));
-            const quelle = gefuehrt ?? { art: 'git', url: kopie.url };
-            const ref = kopie.ref;
-            const skills = await this.p.quellen.skills(quelle, ref);
-            const skill = skills.find((s) => s.pfad === kopie.relativerPfad);
+            const { quelle, ref, skill } = prognose;
+            // Ohne `nurLesend` fragt die Kette den Katalog immer, ein fehlender Skill kommt hier nie an.
             if (skill === undefined) {
-                liegenLassen('skill-unbekannt');
+                eintraege.push({ ergebnis: 'uebersprungen', name, grund: 'skill-unbekannt' });
                 continue;
             }
-            const quelleNeu = gefuehrt === undefined;
+            const quelleNeu = !bekannt.has(quelleSchluessel(quelle));
             bekannt.set(quelleSchluessel(quelle), quelle);
+            const ordnerErsetzt = eintrag.linkZiel === undefined;
             if (!probelauf) {
+                // Vor jeder Wirkung (E57): die Übernahme schreibt ohne `lokal` denselben Zeiger wie
+                // `link`. Die Sperre muss vor `quelleHinzufuegen` greifen, sonst bliebe die Quelle im
+                // Zustand stehen, während der Link nie entsteht. Ein früherer Durchlauf kann nichts
+                // geschrieben haben: er wäre an derselben Stelle abgebrochen.
+                await this.zeigerSchreibenPruefen(args.ziel, args.lokal);
+                // Der abgeleitete Anzeigename kann schon vergeben sein (E59). Die Übernahme hat keinen Weg,
+                // den Nutzer nach einem anderen zu fragen, darum weicht sie auf einen freien aus statt an
+                // QuelleNameBelegt zu scheitern; umbenennen lässt er sich hinterher (source rename).
                 if (quelleNeu)
-                    await this.quelleHinzufuegen(quelle);
+                    await this.quelleHinzufuegen(quelle, quelleNameFrei(quelleNameAbleiten(quelle), (await this.p.zustand.lesen()).quellen));
                 await this.linkAusFund(harness, args.ziel, { quelle, ref, skill }, true, args.lokal);
             }
-            eintraege.push({ ergebnis: 'uebernommen', name, quelle, ref, skill, quelleNeu });
+            // Nur in der Vorschau (E50): welche gitignorierten Dateien beim Ersetzen verloren gingen.
+            // Blockiert nichts, ist reine Sichtbarkeit vor dem echten Lauf.
+            let gitignoriert;
+            if (probelauf && ordnerErsetzt) {
+                const liste = await this.p.quellen
+                    .gitignorierteDateien(path.join(verzeichnis, name))
+                    .catch(() => []);
+                if (liste.length > 0)
+                    gitignoriert = liste;
+            }
+            eintraege.push({
+                ergebnis: 'uebernommen',
+                name,
+                quelle,
+                ref,
+                skill,
+                quelleNeu,
+                ordnerErsetzt,
+                ...(gitignoriert === undefined ? {} : { gitignoriert }),
+            });
         }
+        // Ausdrücklich lokal an einem gebundenen Arbeitsverzeichnis (E57, F32): der Zeiger bleibt
+        // unangetastet, ein Hinweis sagt das. Nur wenn wirklich etwas übernommen wurde und nur bei
+        // bestehender Bindung, sonst wäre es Rauschen.
+        if (!probelauf &&
+            args.lokal === true &&
+            args.ziel.ort.art === 'arbeitsverzeichnis' &&
+            eintraege.some((e) => e.ergebnis === 'uebernommen') &&
+            (await this.bindungFinden(args.ziel)) !== undefined)
+            return {
+                ziel: args.ziel,
+                probelauf,
+                eintraege,
+                hinweis: 'Die übernommenen Links liegen nur lokal, der Zeiger bleibt unangetastet (F32).',
+            };
         return { ziel: args.ziel, probelauf, eintraege };
     }
-    /** Versionseinschränkungen des Zeigers, an den ein Ziel gebunden ist (E33). Ohne Zeiger leer. */
-    async einschraenkungen(ziel) {
-        const ergebnis = new Map();
+    /** Zeiger, an den ein Ziel gebunden ist. Ohne Bindung oder mit unlesbarer Datei: undefined. */
+    async zeigerFuerZiel(ziel) {
         const zeigerPfad = await this.bindungFinden(ziel);
         if (zeigerPfad === undefined)
-            return ergebnis;
-        const zeiger = await this.p.zeiger.lesen(zeigerPfad).catch(() => undefined);
+            return undefined;
+        return await this.p.zeiger.lesen(zeigerPfad).catch(() => undefined);
+    }
+    /** Versionseinschränkungen aus dem Zeiger eines Ziels (E33). Ohne Zeiger leer. */
+    einschraenkungen(zeiger) {
+        const ergebnis = new Map();
         if (zeiger === undefined)
             return ergebnis;
         for (const [name, einschraenkung] of zeiger.skills)
@@ -801,9 +1497,80 @@ export class Anwendungsfaelle {
                 ergebnis.set(name, einschraenkung);
         return ergebnis;
     }
+    /**
+     * Plugins, die für ein Ziel als Grund in Frage kommen: bei einem Arbeitsverzeichnis die des
+     * gebundenen Zeigers, bei Home und Profil die aller Marketplaces der bekannten Quellen.
+     */
+    async pluginKandidaten(ziel, zeiger, marktplatzFunde) {
+        const alle = await marktplatzFunde();
+        if (ziel.ort.art !== 'arbeitsverzeichnis')
+            return alle;
+        if (zeiger === undefined)
+            return [];
+        const funde = [];
+        for (const eintrag of zeiger.plugins) {
+            const zerlegt = pluginSchluesselZerlegen(eintrag);
+            for (const fund of alle)
+                if (fund.plugin.name === zerlegt.name &&
+                    (zerlegt.marketplace === undefined || fund.plugin.marketplace === zerlegt.marketplace))
+                    funde.push(fund);
+        }
+        return funde;
+    }
+    /**
+     * Grund je eigenem Link (E37). Priorität: Plugin vor Zeiger vor manuell. Die Plugin-Zugehörigkeit
+     * steht vorn, weil sie die Einschränkung trägt, dass der Link nicht einzeln entfernt werden darf,
+     * ohne das Plugin zu verletzen. Damit gilt auch ein von Hand gelegter Link, der eine flache
+     * Skill-Liste komplettiert, als Plugin-Link. Diese Unschärfe ist bekannt und akzeptiert.
+     * Bei einem Harness mit Plugin-Fähigkeit sind Plugin-Skills keine hmgr-Links (E16), dort entsteht
+     * der Plugin-Grund nicht. Ist eine Quelle nicht erreichbar, fällt ihr Plugin als Kandidat aus.
+     */
+    async gruende(harness, ziel, eintraege, zeiger, marktplatzFunde) {
+        const gruende = new Map();
+        const eigene = eintraege.filter((e) => e.art !== 'fremd').map((e) => (e.art === 'link' ? e.link.name : e.name));
+        if (eigene.length === 0)
+            return gruende;
+        const eigeneNamen = new Set(eigene);
+        if (!kannPlugins(harness))
+            for (const fund of await this.pluginKandidaten(ziel, zeiger, marktplatzFunde)) {
+                if (!(await this.pluginLiegt(harness, ziel, fund, eintraege).catch(() => false)))
+                    continue;
+                const skills = await this.flacheSkillListe(fund.plugin.name, fund.quelle).catch(() => []);
+                const schluessel = pluginSchluessel(fund.plugin);
+                for (const skill of skills)
+                    if (eigeneNamen.has(skill.name) && !gruende.has(skill.name))
+                        gruende.set(skill.name, { art: 'plugin', plugin: schluessel });
+            }
+        for (const name of eigene)
+            if (!gruende.has(name))
+                gruende.set(name, zeiger?.skills.has(name) === true ? { art: 'zeiger' } : { art: 'manuell' });
+        return gruende;
+    }
     /** Ist-Zustand: alle Ziele der vorhandenen Harnesses, aus dem Dateisystem gelesen. */
     async istZustand() {
         const zustand = await this.p.zustand.lesen();
+        // Je Identität die Quelle, unter deren Schreibweise sie geführt wird (E36, E48), für die
+        // Übernahme-Prognose. Bleibt über den ganzen Lauf gleich, die Prognose verändert nichts.
+        const bekannt = new Map();
+        for (const q of zustand.quellen)
+            bekannt.set(quelleSchluessel(q), q);
+        // Marketplaces der bekannten Quellen, höchstens einmal je Lauf gelesen. Eine unerreichbare
+        // Quelle fällt aus, statt die Erhebung abzubrechen.
+        let gelesene;
+        const marktplatzFunde = async () => {
+            if (gelesene !== undefined)
+                return gelesene;
+            const funde = [];
+            for (const quelle of zustand.quellen) {
+                const marktplatz = await this.marketplaceLesen(quelle).catch(() => null);
+                if (marktplatz === null)
+                    continue;
+                for (const plugin of marktplatz.plugins)
+                    funde.push({ quelle, ref: marktplatz.ref, plugin });
+            }
+            gelesene = funde;
+            return funde;
+        };
         const ergebnis = [];
         for (const harness of await this.vorhandeneHarnesses()) {
             const ziele = [];
@@ -821,12 +1588,39 @@ export class Anwendungsfaelle {
                 const plugins = kannPlugins(harness)
                     ? await harness.plugins.installierte(ziel).catch(() => [])
                     : undefined;
+                const zeiger = await this.zeigerFuerZiel(ziel);
+                const istRegistriert = kannIstRegistriert(harness) ? await harness.istRegistriert(ziel.ort) : false;
+                // Fähigkeit am Typwächter, nicht am Namen (E16), und nur an Orten, die sie kennt.
+                let skillOrdnerFaehig = false;
+                let verwalteterSkillOrdner;
+                if (kannSkillOrdner(harness) && harness.skillOrdnerOrte().includes(ziel.ort.art)) {
+                    skillOrdnerFaehig = true;
+                    verwalteterSkillOrdner = await harness.verwalteterSkillOrdner(ziel.ort);
+                }
+                // Ignoriert (E43): nur Namen fremder Einträge, die tatsächlich noch auf der Platte liegen.
+                // Die Ignorier-Liste selbst wird dabei nicht bereinigt.
+                const fremdeNamen = new Set(eintraege.filter((ei) => ei.art === 'fremd').map((ei) => ei.name));
+                const zielSchl = zielSchluessel(ziel);
+                const ignoriert = zustand.ignorierteEintraege
+                    .filter((i) => zielSchluessel({ harness: i.harness, ort: i.ort }) === zielSchl && fremdeNamen.has(i.name))
+                    .map((i) => i.name);
+                // Übernahme-Prognose je fremdem Eintrag (E48), dieselbe Kette wie `uebernehmen`, nur lesend.
+                const uebernahme = new Map();
+                for (const ei of eintraege)
+                    if (ei.art === 'fremd')
+                        uebernahme.set(ei.name, await this.erkennenFremd(harness, verzeichnis, ei, bekannt, true));
                 ergebnis.push({
                     ziel,
                     verzeichnis,
                     eintraege,
-                    einschraenkungen: await this.einschraenkungen(ziel),
+                    einschraenkungen: this.einschraenkungen(zeiger),
+                    gruende: await this.gruende(harness, ziel, eintraege, zeiger, marktplatzFunde),
+                    ignoriert,
+                    uebernahme,
+                    istRegistriert,
+                    kannSkillOrdner: skillOrdnerFaehig,
                     ...(plugins === undefined ? {} : { plugins }),
+                    ...(verwalteterSkillOrdner === undefined ? {} : { verwalteterSkillOrdner }),
                 });
             }
         }