@cachly-dev/mcp-server 0.10.123 → 0.10.125

package/dist/src/eingaenge.d.ts

@@ -0,0 +1,135 @@
+/**
+ * Eingänge: die zweite Tür zu einer Lektion.
+ *
+ * ── Was gemessen wurde, und was daraus folgt ────────────────────────────────
+ *
+ * Am 20.08.2026 an 499 echten Lektionen mit zwei unabhängigen 100-Fragen-Sätzen
+ * (`.agent/cachly/tor0-tor1-ergebnis.md`):
+ *
+ *   Findequote@3, frischer Prüfsatz
+ *     heute, nur Volltextvektor                              52 %
+ *     Eingänge in der Vorauswahl                             56 %
+ *     dazu das Merkmal "bester Eingang" im Sortierer         58 %
+ *     alle Eingänge AUSSER den Fehlertexten                  52 %   ← null Gewinn
+ *
+ * Die letzte Zeile ist die wichtigste: von fünf ausprobierten Türarten trägt
+ * GENAU EINE. Der erste Satz von what_worked bringt nichts, die Übersetzung
+ * bringt nichts, der Themenname steckt längst im Sortierer. Deshalb baut
+ * dieses Modul nur die Fehlertexte — alles andere wäre Speicher ohne Wirkung.
+ *
+ * ── Warum ausgerechnet der Fehlertext ───────────────────────────────────────
+ *
+ * Er ist ein scharfer Schlüssel. Nutzer fügen Meldungen wörtlich ein; passt der
+ * Schlüssel, zieht er die Lektion nach ganz vorn. Der Preis steht in derselben
+ * Messung und wird hier offen genannt: dieselben Eingänge SENKEN die Decke von
+ * 89 auf 86 % — sie ziehen auch falsche Lektionen in die Vorauswahl. Für den
+ * Nutzer zählt trotzdem die Findequote: er sieht drei Lektionen, nicht 25.
+ *
+ * ── Eine Wahrheit ──────────────────────────────────────────────────────────
+ *
+ * Die Extraktion stand zuerst im Messwerkzeug (src/bench/eingaenge-b.ts). Sie
+ * steht jetzt HIER, und der Bench importiert sie. Zwei Fassungen desselben
+ * regulären Ausdrucks wären die Fehlerklasse, die dieses Haus am häufigsten
+ * trifft — und die Messung würde etwas anderes prüfen als das Produkt.
+ */
+import type { Redis } from 'ioredis';
+/** Wo die Eingänge einer Lektion liegen: EIN Hash je Lektion, neben ihr. */
+export declare const EINGANG_PRAEFIX = "cachly:lesson:eing:";
+/** Höchstens so viele Eingänge je Lektion. Mehr Türen kosten Decke. */
+export declare const EINGAENGE_JE_LEKTION = 3;
+/**
+ * Die Feld-Markierungen, die im Bestand IM Text stehen.
+ *
+ * Gemessen: `what_worked` enthält bei vielen Lektionen wörtlich
+ * `</what_worked>\n<what_failed>`. Wer das nicht wegnimmt, bettet Feldnamen ein
+ * und wundert sich über die Nähe zwischen zwei völlig fremden Lektionen.
+ */
+export declare function ohneMarkierungen(text: string): string;
+/**
+ * Wörtliche Fehlertexte, Codes und Kernsätze aus einer Lektion.
+ *
+ * Fünf Muster, alle an echten Lektionen belegt:
+ *   1. der GROSSGESCHRIEBENE Kernsatz am Anfang (Schreibregel des Hauses)
+ *   2. alles in Anführungszeichen oder Rückwärts-Haken
+ *   3. Fehlerklassen und Meldungen samt Umfeld (Error, panic, FATAL, HTTP 5xx)
+ *   4. Systemfehler-Kürzel MIT Umfeld — "EACCES" allein ist als Vektor blind
+ *   5. englische Meldungssätze mitten im deutschen Text
+ */
+export declare function fehlertexteAus(text: string, hoechstens?: number): string[];
+/** Der Text einer Lektion, aus dem Eingänge gezogen werden. */
+export declare function eingangsText(lektion: Record<string, unknown>): string;
+/**
+ * Schreibt die Eingänge einer Lektion — als EIN Hash, nicht als n Schlüssel.
+ *
+ * Warum ein Hash: die Eingänge gehören zusammen und werden zusammen gelesen.
+ * Drei Schlüssel je Lektion wären bei 2000 Lektionen 6000 Schlüssel im SCAN.
+ *
+ * Der Hash wird zuerst gelöscht: hat sich der Text der Lektion geändert, sind
+ * die alten Fehlertexte falsch. Eine Lektion neu zu lernen darf keine Reste
+ * hinterlassen — das wäre eine zweite Wahrheit über denselben Text.
+ *
+ * Gibt zurück, wie viele Eingänge geschrieben wurden.
+ */
+export declare function schreibeEingaenge(redis: Redis, topic: string, lektion: Record<string, unknown>, einbetten: (text: string) => Promise<number[] | null>): Promise<number>;
+/**
+ * Die Eingänge aller Lektionen im Arbeitsspeicher.
+ *
+ * Baugleich zu `Vektorbestand` in bedeutung.ts und aus demselben Grund: bei
+ * jeder Frage aus dem Speicher zu holen wäre langsamer als der Wortabgleich,
+ * den wir gerade ersetzen. Der MCP-Server läuft lange, also wird einmal geladen
+ * und danach nur nachgetragen.
+ */
+export declare class Eingangsbestand {
+    private readonly frischeMs;
+    private eingaenge;
+    private geladen;
+    constructor(frischeMs?: number);
+    get groesse(): number;
+    get anzahlEingaenge(): number;
+    /**
+     * @param praefixe welche Hashes zum Bestand gehoeren
+     *
+     * Zwei statt einem: die aus dem Text gezogenen Fehlertexte
+     * (`cachly:lesson:eing:`) und die aus der Nutzung gelernten Fragen
+     * (`cachly:lesson:pfad:`). Sie liegen getrennt, weil `schreibeEingaenge`
+     * seinen Hash vor jedem Schreiben loescht — laegen die gelernten Fragen
+     * dort, wuerde jedes erneute Lernen die gesammelte Erfahrung wegwerfen.
+     * Fuer die SUCHE sind sie dasselbe: Tueren zu derselben Lektion.
+     */
+    aktualisiere(redis: Redis, jetzt?: number, praefixe?: readonly string[]): Promise<void>;
+    /**
+     * Die Nähe zum BESTEN Eingang einer Lektion. -2, wenn sie keinen hat.
+     *
+     * Maximum, nicht Mittelwert: eine Lektion wird über ihre passendste Tür
+     * gefunden, und die anderen dürfen schlecht passen. Der Mittelwert würde
+     * Lektionen mit vielen Türen bestrafen — gemessen und belegt am 20.08.
+     */
+    besteNaehe(frage: number[], topic: string): number;
+    /** Die ähnlichsten Lektionen, je Lektion ihr bester Eingang. */
+    aehnlichste(frage: number[], anzahl: number): Array<{
+        topic: string;
+        naehe: number;
+    }>;
+}
+/**
+ * Das Gewicht des Merkmals "bester Eingang" im Sortierer.
+ *
+ * Gemessen am 20.08.2026: 0,3 / 0,5 / 0,8 / 1,3 ergeben 57 / 58 / 57 / 57 %
+ * Findequote@3. Das Merkmal ist also unempfindlich gegen sein Gewicht — wer
+ * hier weiterdreht, misst Rauschen. 0,5 ist die Mitte des flachen Bereichs.
+ */
+export declare const EINGANG_GEWICHT = 0.5;
+/**
+ * Das Urteil über die Deckung des Bedeutungsabgleichs.
+ *
+ * Als eigene Funktion, damit sie prüfbar ist: `brain_doctor` steckt in einem
+ * großen `switch`, und ein Wächter, den man nicht einzeln aufrufen kann, ist
+ * ein Wächter, dessen Nein niemand je gesehen hat.
+ *
+ * Die Schwelle liegt bei 90 Prozent und nicht bei 100: eine einzelne Lektion
+ * ohne Vektor ist ein Aussetzer beim Einbetten (gemessen 20.08.: 7 von 507,
+ * alle beim zweiten Lauf nachgeholt), kein Systemfehler. Null ist etwas ganz
+ * anderes — dann ist der Bedeutungsabgleich schlicht aus.
+ */
+export type Deckungsurteil = 'aus' | 'luecke' | 'gut';
+export declare function beurteileDeckung(lektionen: number, vektoren: number): Deckungsurteil;

package/dist/src/eingaenge.js

@@ -0,0 +1,228 @@
+/**
+ * Eingänge: die zweite Tür zu einer Lektion.
+ *
+ * ── Was gemessen wurde, und was daraus folgt ────────────────────────────────
+ *
+ * Am 20.08.2026 an 499 echten Lektionen mit zwei unabhängigen 100-Fragen-Sätzen
+ * (`.agent/cachly/tor0-tor1-ergebnis.md`):
+ *
+ *   Findequote@3, frischer Prüfsatz
+ *     heute, nur Volltextvektor                              52 %
+ *     Eingänge in der Vorauswahl                             56 %
+ *     dazu das Merkmal "bester Eingang" im Sortierer         58 %
+ *     alle Eingänge AUSSER den Fehlertexten                  52 %   ← null Gewinn
+ *
+ * Die letzte Zeile ist die wichtigste: von fünf ausprobierten Türarten trägt
+ * GENAU EINE. Der erste Satz von what_worked bringt nichts, die Übersetzung
+ * bringt nichts, der Themenname steckt längst im Sortierer. Deshalb baut
+ * dieses Modul nur die Fehlertexte — alles andere wäre Speicher ohne Wirkung.
+ *
+ * ── Warum ausgerechnet der Fehlertext ───────────────────────────────────────
+ *
+ * Er ist ein scharfer Schlüssel. Nutzer fügen Meldungen wörtlich ein; passt der
+ * Schlüssel, zieht er die Lektion nach ganz vorn. Der Preis steht in derselben
+ * Messung und wird hier offen genannt: dieselben Eingänge SENKEN die Decke von
+ * 89 auf 86 % — sie ziehen auch falsche Lektionen in die Vorauswahl. Für den
+ * Nutzer zählt trotzdem die Findequote: er sieht drei Lektionen, nicht 25.
+ *
+ * ── Eine Wahrheit ──────────────────────────────────────────────────────────
+ *
+ * Die Extraktion stand zuerst im Messwerkzeug (src/bench/eingaenge-b.ts). Sie
+ * steht jetzt HIER, und der Bench importiert sie. Zwei Fassungen desselben
+ * regulären Ausdrucks wären die Fehlerklasse, die dieses Haus am häufigsten
+ * trifft — und die Messung würde etwas anderes prüfen als das Produkt.
+ */
+import { kosinus, packe, entpacke } from './bedeutung.js';
+/** Wo die Eingänge einer Lektion liegen: EIN Hash je Lektion, neben ihr. */
+export const EINGANG_PRAEFIX = 'cachly:lesson:eing:';
+/** Höchstens so viele Eingänge je Lektion. Mehr Türen kosten Decke. */
+export const EINGAENGE_JE_LEKTION = 3;
+/**
+ * Die Feld-Markierungen, die im Bestand IM Text stehen.
+ *
+ * Gemessen: `what_worked` enthält bei vielen Lektionen wörtlich
+ * `</what_worked>\n<what_failed>`. Wer das nicht wegnimmt, bettet Feldnamen ein
+ * und wundert sich über die Nähe zwischen zwei völlig fremden Lektionen.
+ */
+export function ohneMarkierungen(text) {
+    return text.replace(/<\/?(what_worked|what_failed|context|topic)>/g, ' ').replace(/\s+/g, ' ').trim();
+}
+/**
+ * Wörtliche Fehlertexte, Codes und Kernsätze aus einer Lektion.
+ *
+ * Fünf Muster, alle an echten Lektionen belegt:
+ *   1. der GROSSGESCHRIEBENE Kernsatz am Anfang (Schreibregel des Hauses)
+ *   2. alles in Anführungszeichen oder Rückwärts-Haken
+ *   3. Fehlerklassen und Meldungen samt Umfeld (Error, panic, FATAL, HTTP 5xx)
+ *   4. Systemfehler-Kürzel MIT Umfeld — "EACCES" allein ist als Vektor blind
+ *   5. englische Meldungssätze mitten im deutschen Text
+ */
+export function fehlertexteAus(text, hoechstens = EINGAENGE_JE_LEKTION) {
+    const t = ohneMarkierungen(text);
+    const aus = [];
+    const nimm = (s) => {
+        if (!s)
+            return;
+        const k = s.replace(/\s+/g, ' ').trim().replace(/^["'`„“]|["'`„“]$/g, '').trim();
+        if (k.length < 8 || k.length > 160)
+            return;
+        if (aus.some((x) => x.toLowerCase() === k.toLowerCase()))
+            return;
+        aus.push(k);
+    };
+    const gross = /^[^a-zäöüß]{15,200}?(?=[.:]|\s[a-zäöüß])/.exec(t);
+    if (gross && /[A-ZÄÖÜ]{3,}/.test(gross[0]))
+        nimm(gross[0]);
+    for (const m of t.matchAll(/[„"'`]([^„"'`\n]{8,160})[“"'`]/g))
+        nimm(m[1]);
+    for (const m of t.matchAll(/\b((?:[A-Z][a-zA-Z]*(?:Error|Exception)|panic:|FATAL|ERROR|Traceback|exit(?:ed with)? (?:code )?\d+|HTTP [45]\d{2}|status [45]\d{2})[^.\n]{0,90})/g))
+        nimm(m[1]);
+    for (const m of t.matchAll(/\b(E[A-Z]{3,10}\b[^.\n]{0,60})/g))
+        nimm(m[1]);
+    for (const m of t.matchAll(/\b((?:no such|not found|permission denied|connection refused|no space left|too many|already exists|cannot|failed to|unable to)[^.,;\n]{0,70})/gi))
+        nimm(m[1]);
+    return aus.slice(0, hoechstens);
+}
+/** Der Text einer Lektion, aus dem Eingänge gezogen werden. */
+export function eingangsText(lektion) {
+    const s = (v) => (typeof v === 'string' ? v : '');
+    return `${s(lektion.what_worked)}\n${s(lektion.what_failed)}`;
+}
+/**
+ * Schreibt die Eingänge einer Lektion — als EIN Hash, nicht als n Schlüssel.
+ *
+ * Warum ein Hash: die Eingänge gehören zusammen und werden zusammen gelesen.
+ * Drei Schlüssel je Lektion wären bei 2000 Lektionen 6000 Schlüssel im SCAN.
+ *
+ * Der Hash wird zuerst gelöscht: hat sich der Text der Lektion geändert, sind
+ * die alten Fehlertexte falsch. Eine Lektion neu zu lernen darf keine Reste
+ * hinterlassen — das wäre eine zweite Wahrheit über denselben Text.
+ *
+ * Gibt zurück, wie viele Eingänge geschrieben wurden.
+ */
+export async function schreibeEingaenge(redis, topic, lektion, einbetten) {
+    const texte = fehlertexteAus(eingangsText(lektion));
+    const schluessel = `${EINGANG_PRAEFIX}${topic}`;
+    if (texte.length === 0) {
+        // Kein Fehlertext in dieser Lektion — dann bekommt sie keinen Eingang.
+        // Eine leere Tür ist besser als eine erfundene.
+        await redis.del(schluessel);
+        return 0;
+    }
+    const felder = [];
+    for (const text of texte) {
+        const v = await einbetten(text);
+        if (v?.length)
+            felder.push(text.slice(0, 200), packe(v));
+    }
+    if (felder.length === 0)
+        return 0;
+    await redis.del(schluessel);
+    await redis.hset(schluessel, ...felder);
+    return felder.length / 2;
+}
+/**
+ * Die Eingänge aller Lektionen im Arbeitsspeicher.
+ *
+ * Baugleich zu `Vektorbestand` in bedeutung.ts und aus demselben Grund: bei
+ * jeder Frage aus dem Speicher zu holen wäre langsamer als der Wortabgleich,
+ * den wir gerade ersetzen. Der MCP-Server läuft lange, also wird einmal geladen
+ * und danach nur nachgetragen.
+ */
+export class Eingangsbestand {
+    frischeMs;
+    eingaenge = new Map();
+    geladen = 0;
+    constructor(frischeMs = 60_000) {
+        this.frischeMs = frischeMs;
+    }
+    get groesse() { return this.eingaenge.size; }
+    get anzahlEingaenge() {
+        let n = 0;
+        for (const vs of this.eingaenge.values())
+            n += vs.length;
+        return n;
+    }
+    /**
+     * @param praefixe welche Hashes zum Bestand gehoeren
+     *
+     * Zwei statt einem: die aus dem Text gezogenen Fehlertexte
+     * (`cachly:lesson:eing:`) und die aus der Nutzung gelernten Fragen
+     * (`cachly:lesson:pfad:`). Sie liegen getrennt, weil `schreibeEingaenge`
+     * seinen Hash vor jedem Schreiben loescht — laegen die gelernten Fragen
+     * dort, wuerde jedes erneute Lernen die gesammelte Erfahrung wegwerfen.
+     * Fuer die SUCHE sind sie dasselbe: Tueren zu derselben Lektion.
+     */
+    async aktualisiere(redis, jetzt = Date.now(), praefixe = [EINGANG_PRAEFIX, 'cachly:lesson:pfad:']) {
+        if (this.eingaenge.size > 0 && jetzt - this.geladen < this.frischeMs)
+            return;
+        const frisch = new Map();
+        for (const praefix of praefixe) {
+            const schluessel = [];
+            let cursor = '0';
+            do {
+                const [next, gefunden] = await redis.scan(cursor, 'MATCH', `${praefix}*`, 'COUNT', 500);
+                cursor = next;
+                schluessel.push(...gefunden);
+            } while (cursor !== '0');
+            for (const k of schluessel) {
+                const hash = await redis.hgetall(k);
+                const topic = k.slice(praefix.length);
+                const vs = frisch.get(topic) ?? [];
+                for (const roh of Object.values(hash)) {
+                    const v = entpacke(roh);
+                    if (v)
+                        vs.push(v);
+                }
+                if (vs.length)
+                    frisch.set(topic, vs);
+            }
+        }
+        this.eingaenge = frisch;
+        this.geladen = jetzt;
+    }
+    /**
+     * Die Nähe zum BESTEN Eingang einer Lektion. -2, wenn sie keinen hat.
+     *
+     * Maximum, nicht Mittelwert: eine Lektion wird über ihre passendste Tür
+     * gefunden, und die anderen dürfen schlecht passen. Der Mittelwert würde
+     * Lektionen mit vielen Türen bestrafen — gemessen und belegt am 20.08.
+     */
+    besteNaehe(frage, topic) {
+        const vs = this.eingaenge.get(topic);
+        if (!vs?.length)
+            return -2;
+        let best = -2;
+        for (const v of vs) {
+            const k = kosinus(frage, v);
+            if (k > best)
+                best = k;
+        }
+        return best;
+    }
+    /** Die ähnlichsten Lektionen, je Lektion ihr bester Eingang. */
+    aehnlichste(frage, anzahl) {
+        const aus = [];
+        for (const topic of this.eingaenge.keys()) {
+            aus.push({ topic, naehe: this.besteNaehe(frage, topic) });
+        }
+        aus.sort((a, b) => b.naehe - a.naehe);
+        return aus.slice(0, anzahl);
+    }
+}
+/**
+ * Das Gewicht des Merkmals "bester Eingang" im Sortierer.
+ *
+ * Gemessen am 20.08.2026: 0,3 / 0,5 / 0,8 / 1,3 ergeben 57 / 58 / 57 / 57 %
+ * Findequote@3. Das Merkmal ist also unempfindlich gegen sein Gewicht — wer
+ * hier weiterdreht, misst Rauschen. 0,5 ist die Mitte des flachen Bereichs.
+ */
+export const EINGANG_GEWICHT = 0.5;
+export function beurteileDeckung(lektionen, vektoren) {
+    if (lektionen === 0)
+        return 'gut'; // Ein leeres Brain ist nicht krank.
+    if (vektoren === 0)
+        return 'aus';
+    return (vektoren / lektionen) * 100 < 90 ? 'luecke' : 'gut';
+}
+//# sourceMappingURL=eingaenge.js.map

package/dist/src/eingaenge.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"eingaenge.js","sourceRoot":"","sources":["../../src/eingaenge.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AAGH,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAE1D,4EAA4E;AAC5E,MAAM,CAAC,MAAM,eAAe,GAAG,qBAAqB,CAAC;AAErD,uEAAuE;AACvE,MAAM,CAAC,MAAM,oBAAoB,GAAG,CAAC,CAAC;AAEtC;;;;;;GAMG;AACH,MAAM,UAAU,gBAAgB,CAAC,IAAY;IAC3C,OAAO,IAAI,CAAC,OAAO,CAAC,+CAA+C,EAAE,GAAG,CAAC,CAAC,OAAO,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC,IAAI,EAAE,CAAC;AACxG,CAAC;AAED;;;;;;;;;GASG;AACH,MAAM,UAAU,cAAc,CAAC,IAAY,EAAE,UAAU,GAAG,oBAAoB;IAC5E,MAAM,CAAC,GAAG,gBAAgB,CAAC,IAAI,CAAC,CAAC;IACjC,MAAM,GAAG,GAAa,EAAE,CAAC;IACzB,MAAM,IAAI,GAAG,CAAC,CAAqB,EAAQ,EAAE;QAC3C,IAAI,CAAC,CAAC;YAAE,OAAO;QACf,MAAM,CAAC,GAAG,CAAC,CAAC,OAAO,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC,IAAI,EAAE,CAAC,OAAO,CAAC,oBAAoB,EAAE,EAAE,CAAC,CAAC,IAAI,EAAE,CAAC;QACjF,IAAI,CAAC,CAAC,MAAM,GAAG,CAAC,IAAI,CAAC,CAAC,MAAM,GAAG,GAAG;YAAE,OAAO;QAC3C,IAAI,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,WAAW,EAAE,KAAK,CAAC,CAAC,WAAW,EAAE,CAAC;YAAE,OAAO;QACjE,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;IACd,CAAC,CAAC;IAEF,MAAM,KAAK,GAAG,0CAA0C,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;IACjE,IAAI,KAAK,IAAI,cAAc,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;QAAE,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;IAE3D,KAAK,MAAM,CAAC,IAAI,CAAC,CAAC,QAAQ,CAAC,iCAAiC,CAAC;QAAE,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;IAE1E,KAAK,MAAM,CAAC,IAAI,CAAC,CAAC,QAAQ,CACxB,oJAAoJ,CACrJ;QAAE,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;IAEd,KAAK,MAAM,CAAC,IAAI,CAAC,CAAC,QAAQ,CAAC,iCAAiC,CAAC;QAAE,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;IAE1E,KAAK,MAAM,CAAC,IAAI,CAAC,CAAC,QAAQ,CACxB,iJAAiJ,CAClJ;QAAE,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;IAEd,OAAO,GAAG,CAAC,KAAK,CAAC,CAAC,EAAE,UAAU,CAAC,CAAC;AAClC,CAAC;AAED,+DAA+D;AAC/D,MAAM,UAAU,YAAY,CAAC,OAAgC;IAC3D,MAAM,CAAC,GAAG,CAAC,CAAU,EAAU,EAAE,CAAC,CAAC,OAAO,CAAC,KAAK,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;IACnE,OAAO,GAAG,CAAC,CAAC,OAAO,CAAC,WAAW,CAAC,KAAK,CAAC,CAAC,OAAO,CAAC,WAAW,CAAC,EAAE,CAAC;AAChE,CAAC;AAED;;;;;;;;;;;GAWG;AACH,MAAM,CAAC,KAAK,UAAU,iBAAiB,CACrC,KAAY,EACZ,KAAa,EACb,OAAgC,EAChC,SAAqD;IAErD,MAAM,KAAK,GAAG,cAAc,CAAC,YAAY,CAAC,OAAO,CAAC,CAAC,CAAC;IACpD,MAAM,UAAU,GAAG,GAAG,eAAe,GAAG,KAAK,EAAE,CAAC;IAEhD,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QACvB,uEAAuE;QACvE,gDAAgD;QAChD,MAAM,KAAK,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC;QAC5B,OAAO,CAAC,CAAC;IACX,CAAC;IAED,MAAM,MAAM,GAAa,EAAE,CAAC;IAC5B,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE,CAAC;QACzB,MAAM,CAAC,GAAG,MAAM,SAAS,CAAC,IAAI,CAAC,CAAC;QAChC,IAAI,CAAC,EAAE,MAAM;YAAE,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,EAAE,GAAG,CAAC,EAAE,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;IAC3D,CAAC;IACD,IAAI,MAAM,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,CAAC,CAAC;IAElC,MAAM,KAAK,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC;IAC5B,MAAM,KAAK,CAAC,IAAI,CAAC,UAAU,EAAE,GAAG,MAAM,CAAC,CAAC;IACxC,OAAO,MAAM,CAAC,MAAM,GAAG,CAAC,CAAC;AAC3B,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,OAAO,eAAe;IAIG;IAHrB,SAAS,GAAG,IAAI,GAAG,EAAsB,CAAC;IAC1C,OAAO,GAAG,CAAC,CAAC;IAEpB,YAA6B,YAAY,MAAM;QAAlB,cAAS,GAAT,SAAS,CAAS;IAAG,CAAC;IAEnD,IAAI,OAAO,KAAa,OAAO,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC,CAAC;IAErD,IAAI,eAAe;QACjB,IAAI,CAAC,GAAG,CAAC,CAAC;QACV,KAAK,MAAM,EAAE,IAAI,IAAI,CAAC,SAAS,CAAC,MAAM,EAAE;YAAE,CAAC,IAAI,EAAE,CAAC,MAAM,CAAC;QACzD,OAAO,CAAC,CAAC;IACX,CAAC;IAED;;;;;;;;;OASG;IACH,KAAK,CAAC,YAAY,CAChB,KAAY,EACZ,KAAK,GAAG,IAAI,CAAC,GAAG,EAAE,EAClB,WAA8B,CAAC,eAAe,EAAE,qBAAqB,CAAC;QAEtE,IAAI,IAAI,CAAC,SAAS,CAAC,IAAI,GAAG,CAAC,IAAI,KAAK,GAAG,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC,SAAS;YAAE,OAAO;QAE7E,MAAM,MAAM,GAAG,IAAI,GAAG,EAAsB,CAAC;QAC7C,KAAK,MAAM,OAAO,IAAI,QAAQ,EAAE,CAAC;YAC/B,MAAM,UAAU,GAAa,EAAE,CAAC;YAChC,IAAI,MAAM,GAAG,GAAG,CAAC;YACjB,GAAG,CAAC;gBACF,MAAM,CAAC,IAAI,EAAE,QAAQ,CAAC,GAAG,MAAM,KAAK,CAAC,IAAI,CAAC,MAAM,EAAE,OAAO,EAAE,GAAG,OAAO,GAAG,EAAE,OAAO,EAAE,GAAG,CAAC,CAAC;gBACxF,MAAM,GAAG,IAAI,CAAC;gBACd,UAAU,CAAC,IAAI,CAAC,GAAG,QAAQ,CAAC,CAAC;YAC/B,CAAC,QAAQ,MAAM,KAAK,GAAG,EAAE;YAEzB,KAAK,MAAM,CAAC,IAAI,UAAU,EAAE,CAAC;gBAC3B,MAAM,IAAI,GAAG,MAAM,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC;gBACpC,MAAM,KAAK,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;gBACtC,MAAM,EAAE,GAAG,MAAM,CAAC,GAAG,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC;gBACnC,KAAK,MAAM,GAAG,IAAI,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE,CAAC;oBACtC,MAAM,CAAC,GAAG,QAAQ,CAAC,GAAG,CAAC,CAAC;oBACxB,IAAI,CAAC;wBAAE,EAAE,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;gBACpB,CAAC;gBACD,IAAI,EAAE,CAAC,MAAM;oBAAE,MAAM,CAAC,GAAG,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC;YACvC,CAAC;QACH,CAAC;QACD,IAAI,CAAC,SAAS,GAAG,MAAM,CAAC;QACxB,IAAI,CAAC,OAAO,GAAG,KAAK,CAAC;IACvB,CAAC;IAED;;;;;;OAMG;IACH,UAAU,CAAC,KAAe,EAAE,KAAa;QACvC,MAAM,EAAE,GAAG,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;QACrC,IAAI,CAAC,EAAE,EAAE,MAAM;YAAE,OAAO,CAAC,CAAC,CAAC;QAC3B,IAAI,IAAI,GAAG,CAAC,CAAC,CAAC;QACd,KAAK,MAAM,CAAC,IAAI,EAAE,EAAE,CAAC;YACnB,MAAM,CAAC,GAAG,OAAO,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC;YAC5B,IAAI,CAAC,GAAG,IAAI;gBAAE,IAAI,GAAG,CAAC,CAAC;QACzB,CAAC;QACD,OAAO,IAAI,CAAC;IACd,CAAC;IAED,gEAAgE;IAChE,WAAW,CAAC,KAAe,EAAE,MAAc;QACzC,MAAM,GAAG,GAA4C,EAAE,CAAC;QACxD,KAAK,MAAM,KAAK,IAAI,IAAI,CAAC,SAAS,CAAC,IAAI,EAAE,EAAE,CAAC;YAC1C,GAAG,CAAC,IAAI,CAAC,EAAE,KAAK,EAAE,KAAK,EAAE,IAAI,CAAC,UAAU,CAAC,KAAK,EAAE,KAAK,CAAC,EAAE,CAAC,CAAC;QAC5D,CAAC;QACD,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,KAAK,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC;QACtC,OAAO,GAAG,CAAC,KAAK,CAAC,CAAC,EAAE,MAAM,CAAC,CAAC;IAC9B,CAAC;CACF;AAED;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,eAAe,GAAG,GAAG,CAAC;AAgBnC,MAAM,UAAU,gBAAgB,CAAC,SAAiB,EAAE,QAAgB;IAClE,IAAI,SAAS,KAAK,CAAC;QAAE,OAAO,KAAK,CAAC,CAAO,oCAAoC;IAC7E,IAAI,QAAQ,KAAK,CAAC;QAAE,OAAO,KAAK,CAAC;IACjC,OAAO,CAAC,QAAQ,GAAG,SAAS,CAAC,GAAG,GAAG,GAAG,EAAE,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,KAAK,CAAC;AAC9D,CAAC"}

package/dist/src/geliefert.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Wie viel Text kam aus dem Gedaechtnis statt aus dem Modell?
+ *
+ * ANLASS 19.08.2026, Heinrich: "Bei der Schaetzung der Tokenersparnis sollten
+ * wir schauen, dass wir nicht nur schaetzen, denn das nervt Leute sehr stark.
+ * Vielleicht machen wir eine weitere Metrik rein? Sowas wie Token, die bei den
+ * Calls aus dem Brain rausgenommen wurden und nicht aus der AI vom Vendor
+ * kamen?"
+ *
+ * ── Warum das die bessere Zahl ist ──────────────────────────────────────────
+ *
+ * Die bisherige Zahl "583k Token gespart" ist eine RECHNUNG: 1.200 Token je
+ * wiederverwendeter Lektion mal 486 Abrufe. Der Faktor 1.200 ist geraten, und
+ * jeder darf ihn bestreiten. Die Zahl hier ist eine SUMME: die Laenge der
+ * Antworten, die das Brain wirklich zurueckgegeben hat. Da gibt es nichts zu
+ * bestreiten — hoechstens die Frage, was sie bedeutet.
+ *
+ * ── Was sie NICHT sagt ──────────────────────────────────────────────────────
+ *
+ * Sie ist KEIN Beweis, dass das Modell diese Token sonst selbst erzeugt haette.
+ * Vielleicht haette es die Antwort gar nicht gefunden, vielleicht kuerzer
+ * geantwortet. Sie sagt genau eines, und das laesst sich nachrechnen: so viel
+ * Text kam als Antwort aus dem Gedaechtnis. Wer mehr behauptet, schaetzt
+ * wieder.
+ *
+ * Deshalb steht die Schaetzung weiter daneben — aber klein, mit ihrer Annahme
+ * im selben Satz, und neben einer Zahl, die keine braucht.
+ */
+/**
+ * Nur ABRUFE zaehlen, nicht jede Antwort.
+ *
+ * `learn_from_attempts` gibt eine Bestaetigung zurueck, `create_instance` eine
+ * Kennung — das ist kein geliefertes Wissen. Gezaehlt wird, was Gespeichertes
+ * herausgibt. Steht ein Werkzeug nicht auf dieser Liste, zaehlt es nicht mit;
+ * die Zahl ist dadurch eher zu klein als zu gross, und das ist die richtige
+ * Richtung fuer eine Zahl, mit der man wirbt.
+ */
+export declare const LIEFERNDE_WERKZEUGE: Set<string>;
+export declare function istLieferung(werkzeugName: string): boolean;
+/** Redis-Schluessel je Brain: Summe der gelieferten Token. */
+export declare function lieferSchluessel(instanceId: string): string;
+/** Redis-Schluessel je Brain: Abrufe gesamt und davon mit Treffer. */
+export declare function trefferSchluessel(instanceId: string): string;
+export declare function hatTreffer(antwort: string): boolean;
+/** Die Token dieser Antwort — dieselbe Schaetzfunktion wie beim Einblende-Budget. */
+export declare function tokenDerAntwort(antwort: string): number;
+export interface LieferBild {
+    /** Summe der gelieferten Token. */
+    token: number;
+    /** Abrufe insgesamt. */
+    abrufe: number;
+    /** Davon mit mindestens einem Treffer. */
+    treffer: number;
+    /** treffer/abrufe, 0..1. Bei 0 Abrufen: 0. */
+    quote: number;
+}
+export declare function lieferBild(roh: {
+    token?: string | number | null;
+    abrufe?: string | number | null;
+    treffer?: string | number | null;
+}): LieferBild;
+/** Grosse Zahlen so, wie ein Mensch sie liest. */
+export declare function inWorten(bild: LieferBild): string;

package/dist/src/geliefert.js

@@ -0,0 +1,114 @@
+import { estimateTokens } from './ambient-recall.js';
+/**
+ * Wie viel Text kam aus dem Gedaechtnis statt aus dem Modell?
+ *
+ * ANLASS 19.08.2026, Heinrich: "Bei der Schaetzung der Tokenersparnis sollten
+ * wir schauen, dass wir nicht nur schaetzen, denn das nervt Leute sehr stark.
+ * Vielleicht machen wir eine weitere Metrik rein? Sowas wie Token, die bei den
+ * Calls aus dem Brain rausgenommen wurden und nicht aus der AI vom Vendor
+ * kamen?"
+ *
+ * ── Warum das die bessere Zahl ist ──────────────────────────────────────────
+ *
+ * Die bisherige Zahl "583k Token gespart" ist eine RECHNUNG: 1.200 Token je
+ * wiederverwendeter Lektion mal 486 Abrufe. Der Faktor 1.200 ist geraten, und
+ * jeder darf ihn bestreiten. Die Zahl hier ist eine SUMME: die Laenge der
+ * Antworten, die das Brain wirklich zurueckgegeben hat. Da gibt es nichts zu
+ * bestreiten — hoechstens die Frage, was sie bedeutet.
+ *
+ * ── Was sie NICHT sagt ──────────────────────────────────────────────────────
+ *
+ * Sie ist KEIN Beweis, dass das Modell diese Token sonst selbst erzeugt haette.
+ * Vielleicht haette es die Antwort gar nicht gefunden, vielleicht kuerzer
+ * geantwortet. Sie sagt genau eines, und das laesst sich nachrechnen: so viel
+ * Text kam als Antwort aus dem Gedaechtnis. Wer mehr behauptet, schaetzt
+ * wieder.
+ *
+ * Deshalb steht die Schaetzung weiter daneben — aber klein, mit ihrer Annahme
+ * im selben Satz, und neben einer Zahl, die keine braucht.
+ */
+/**
+ * Nur ABRUFE zaehlen, nicht jede Antwort.
+ *
+ * `learn_from_attempts` gibt eine Bestaetigung zurueck, `create_instance` eine
+ * Kennung — das ist kein geliefertes Wissen. Gezaehlt wird, was Gespeichertes
+ * herausgibt. Steht ein Werkzeug nicht auf dieser Liste, zaehlt es nicht mit;
+ * die Zahl ist dadurch eher zu klein als zu gross, und das ist die richtige
+ * Richtung fuer eine Zahl, mit der man wirbt.
+ */
+export const LIEFERNDE_WERKZEUGE = new Set([
+    'smart_recall',
+    'recall_best_solution',
+    'recall_context',
+    'recall_at',
+    'causal_trace',
+    'semantic_search',
+    'brain_search',
+    'team_recall',
+    'global_recall',
+    'session_start',
+    'session_start_summary',
+    'brain_briefing',
+    'compact_recover',
+    'session_handoff',
+    'crystal_view',
+    'brain_graph',
+    'trace_dependency',
+    'brain_who_knows',
+    'fedbrain_search',
+    'syndicate_search',
+]);
+export function istLieferung(werkzeugName) {
+    return LIEFERNDE_WERKZEUGE.has(werkzeugName);
+}
+/** Redis-Schluessel je Brain: Summe der gelieferten Token. */
+export function lieferSchluessel(instanceId) {
+    return `cachly:stats:delivered_tokens:${instanceId}`;
+}
+/** Redis-Schluessel je Brain: Abrufe gesamt und davon mit Treffer. */
+export function trefferSchluessel(instanceId) {
+    return `cachly:stats:recall_hits:${instanceId}`;
+}
+/**
+ * Hatte dieser Abruf einen Treffer?
+ *
+ * Erkannt an dem, was die Antwort SAGT, nicht an ihrer Laenge: eine hoefliche
+ * Absage ("keine passende Lektion gefunden") ist laenger als mancher Treffer.
+ * Die Muster stammen aus den Antworttexten der Abruf-Werkzeuge selbst.
+ */
+const LEERE_ANTWORT = /(no (relevant |matching |cached )?(lessons?|results?|context|memory|match)|keine? (passende|relevante)|nothing (found|cached)|0 results|Results \(0\b|empty)/i;
+export function hatTreffer(antwort) {
+    if (!antwort || antwort.trim().length === 0)
+        return false;
+    return !LEERE_ANTWORT.test(antwort);
+}
+/** Die Token dieser Antwort — dieselbe Schaetzfunktion wie beim Einblende-Budget. */
+export function tokenDerAntwort(antwort) {
+    return estimateTokens(antwort);
+}
+export function lieferBild(roh) {
+    const zahl = (v) => {
+        const n = typeof v === 'number' ? v : Number(v ?? 0);
+        return Number.isFinite(n) && n > 0 ? Math.floor(n) : 0;
+    };
+    const token = zahl(roh.token);
+    const abrufe = zahl(roh.abrufe);
+    const treffer = Math.min(zahl(roh.treffer), abrufe);
+    return { token, abrufe, treffer, quote: abrufe > 0 ? treffer / abrufe : 0 };
+}
+/** Grosse Zahlen so, wie ein Mensch sie liest. */
+export function inWorten(bild) {
+    if (bild.abrufe === 0) {
+        return 'Aus dem Brain geliefert: noch nichts — es gab bisher keinen Abruf.';
+    }
+    const t = bild.token >= 1_000_000
+        ? `${(bild.token / 1_000_000).toFixed(2)} Mio.`
+        : bild.token >= 1_000
+            ? `${Math.round(bild.token / 1_000)}k`
+            : `${bild.token}`;
+    const prozent = Math.round(bild.quote * 100);
+    return (`Aus dem Brain geliefert: ${t} Token in ${bild.abrufe} Abrufen. ` +
+        `${bild.treffer} davon fanden etwas (${prozent} %). ` +
+        `Gemessen, nicht gerechnet — es ist die Summe der Antwortlaengen, keine Annahme.`);
+}
+//# sourceMappingURL=geliefert.js.map

package/dist/src/geliefert.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"geliefert.js","sourceRoot":"","sources":["../../src/geliefert.ts"],"names":[],"mappings":"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"}

package/dist/src/handlers/advanced.js

@@ -1,5 +1,6 @@
 import { ckgSlug } from '../ckg.js';
 import { safeJsonParse } from '../utils.js';
+import { ersparteMinuten } from '../wertbeitrag.js';
 export const ADVANCED_TOOL_NAMES = new Set([
     'memory_consolidate', 'brain_diff', 'causal_trace', 'knowledge_decay', 'autopilot',
 ]);
@@ -377,9 +378,12 @@ export async function handleAdvancedTool(name, args, getConnection, _apiFetch) {
                     lines.push(topSolution.what_worked.slice(0, 500));
                     lines.push(`\`\`\``);
                     lines.push('');
-                    // Track estimated time saved — causal_trace finding a known fix is worth 1-4h
-                    const savedMins = topSolution.severity === 'critical' ? 240 : topSolution.severity === 'major' ? 120 : 60;
-                    redis.incrbyfloat(`cachly:stats:time_saved_mins:${instance_id}`, savedMins).catch(() => { });
+                    // Track estimated time saved — causal_trace finding a known fix is worth 1-4h.
+                    // Starter-Lektionen zaehlen 0 — siehe wertbeitrag.ts.
+                    const savedMins = ersparteMinuten(topSolution, 'trace');
+                    if (savedMins > 0) {
+                        redis.incrbyfloat(`cachly:stats:time_saved_mins:${instance_id}`, savedMins).catch(() => { });
+                    }
                 }
             }
             lines.push(`💡 After applying: \`learn_from_attempts(topic="fix:${tokens[0] ?? 'issue'}", outcome="success", ...)\``);