@cachly-dev/mcp-server 0.10.129 → 0.10.131

package/dist/src/rangfolge.js

@@ -1,249 +1 @@
-/**
- * Der zusammengesetzte Sortierer.
- *
- * ── Was hier drinsteckt, und was NICHT ──────────────────────────────────────
- *
- * Am 19.08.2026 wurden an 499 echten Lektionen mit 100 Fragen ein Dutzend
- * Verfahren durchgemessen. Die meisten haben nichts gebracht. Sie stehen hier,
- * damit sie niemand ein zweites Mal baut:
- *
- *   Symptom-Sicht (what_failed als eigener Vektor)   17 % statt 40 % — das Feld
- *     beschreibt bei uns nicht das Symptom, sondern was vergeblich versucht wurde
- *   Schwerpunkt abziehen                             41 % — im Rauschen
- *   Hauptrichtungen entfernen (1, 3, 6 Stueck)       37–41 % — im Rauschen
- *   Nabenabzug (CSLS-artig)                          41 % — im Rauschen
- *   Text in Stuecke schneiden                        nicht gebaut: gemessen deckt
- *     das beste Stueck genauso viel ab wie der ganze Text (Verhaeltnis 1,00),
- *     und es liegt bei 86 von 96 Fragen ohnehin am Anfang
- *
- * Was BLEIBT, sind vier Bestandteile — kreuzweise geprueft, also auf der einen
- * Haelfte der Fragen eingestellt und auf der anderen gemessen, in beide
- * Richtungen:
- *
- *                        P@1     MRR
- *   nur Bedeutung        40 %   51,3 %
- *   zusammengesetzt      51 %   57,0 %
- *
- * ── Die vier Bestandteile ───────────────────────────────────────────────────
- *
- * 1. NAEHE ZUM GANZEN TEXT (Sicht A). Der Grundstock.
- *
- * 2. NAEHE ZUM THEMENNAMEN (Sicht C). Der Name ist kurz wie eine Frage — der
- *    Vergleich ist damit symmetrisch, waehrend eine 60-Zeichen-Frage gegen
- *    1376 Zeichen Text es nicht ist. Allein liefert diese Sicht nur 26 %, im
- *    Verbund traegt sie verlaesslich (Gewicht 0,6 in beiden Richtungen).
- *
- * 3. RUECKKOPPLUNG. Die ersten drei Treffer sind meistens ungefaehr richtig.
- *    Ihre Vektoren werden zu einem Viertel unter die Frage gemischt, dann wird
- *    erneut verglichen. Kostet nichts — keine neue Einbettung, nur eine
- *    Mittelung vorhandener Zahlen.
- *
- * 4. SELTENHEITS-UEBERLAPPUNG. Welcher Anteil der SELTENEN Fragewoerter kommt
- *    im Text vor. Ohne Laengennormierung, ohne unscharfe Treffer, ohne
- *    Bigramme.
- *
- *    Das ist der unbequeme Befund: dieses eine Verhaeltnis bekam beim Einstellen
- *    das Gewicht 1,0 bis 1,6 — unser ausgefeiltes BM25 mit Laengennormierung,
- *    Bigramm-Naehe, unscharfen Treffern und Frischebonus bekam NULL. Nicht weil
- *    Woerter nichts taugen, sondern weil das ganze Beiwerk beim Sortieren
- *    daneben misst.
- *
- * ── Warum innerhalb des Topfes normiert wird ────────────────────────────────
- *
- * Ueber den ganzen Bestand liegen alle Aehnlichkeiten zwischen 0,42 und 0,61 —
- * ein sehr schmales Band, weil alle Vektoren eine gemeinsame Grundrichtung
- * teilen (gemessen: 69,8 Prozent). Unter fuenfzig Kandidaten spreizt eine
- * Normierung auf 0 bis 1 genau die Unterschiede auf, um die es geht. Das ist
- * dasselbe Ziel wie beim Schwerpunkt-Abziehen — nur dort, wo es wirkt.
- */
-import { kosinus } from './bedeutung.js';
-/** Wörter eines Textes, umlautfrei, ohne Kurzwörter. */
-export function inhaltsWoerter(text) {
-    return new Set(text.toLowerCase()
-        .replace(/ä/g, 'ae').replace(/ö/g, 'oe').replace(/ü/g, 'ue').replace(/ß/g, 'ss')
-        .split(/[^a-z0-9]+/)
-        .filter((w) => w.length > 3));
-}
-/**
- * Es gibt hier KEINE Stammbildung — und das ist gemessen, nicht vergessen.
- *
- * Naheliegend wäre, `Abhaengigkeiten` und `Abhaengigkeit` auf einen Nenner zu
- * bringen. Drei Varianten wurden am 19.08.2026 an 499 Lektionen mit 100 Fragen
- * kreuzweise durchgemessen:
- *
- *   ohne Stammbildung          P@1 50 %   MRR 56,4 %
- *   erste 6 Zeichen            P@1 47 %   MRR 54,7 %
- *   erste 8 Zeichen            P@1 47 %   MRR 54,7 %
- *
- * Jede Form von Kürzen kostet drei Punkte. Der Grund liegt daran, was diese
- * Suche trägt: seltene Fachwörter. `fail2ban`, `stampede`, `timestamptz`,
- * `keycloak` entscheiden eine Frage praktisch allein — und jede Verschmelzung
- * verwischt genau sie. `container` und `contains` werden zu demselben Wort,
- * und aus zwei seltenen wird ein häufiges.
- *
- * Beugung einzufangen lohnt sich also nur, wo die häufigen Wörter zählen. Hier
- * zählen die seltenen.
- *
- * (Die Wortform-Behandlung in deutsch.ts bleibt davon unberührt — sie wirkt im
- * Wortabgleich, der die Vorauswahl macht, nicht in dieser Bewertung.)
- */
-export function grobStamm(w) {
-    return w;
-}
-/**
- * Die Seltenheit jedes Wortes im Bestand — einmal berechnet, oft benutzt.
- *
- * Trifft eine Frage das Wort "nicht", sagt das nichts. Trifft sie "fail2ban",
- * ist die Sache praktisch entschieden. Ohne diese Gewichtung sind beide gleich
- * viel wert.
- */
-export class Seltenheit {
-    df = new Map();
-    anzahl = 0;
-    /** @param texte je ein Text pro Datensatz */
-    constructor(texte) {
-        this.anzahl = texte.length;
-        for (const t of texte) {
-            for (const w of inhaltsWoerter(t))
-                this.df.set(grobStamm(w), (this.df.get(grobStamm(w)) ?? 0) + 1);
-        }
-    }
-    wert(wort) {
-        return Math.log((this.anzahl + 1) / ((this.df.get(grobStamm(wort)) ?? 0) + 1));
-    }
-    /**
-     * Welcher Anteil der seltenen Fragewörter kommt im Text vor.
-     *
-     * Der Nenner ist die Summe über ALLE Fragewörter — ein fehlendes seltenes
-     * Wort zieht damit den Wert herunter. Fehlende Belege zählen also mit, nicht
-     * nur vorhandene.
-     */
-    deckung(frageWoerter, textWoerter) {
-        let gesamt = 0;
-        let getroffen = 0;
-        for (const w of frageWoerter) {
-            const g = this.wert(w);
-            gesamt += g;
-            if (textWoerter.has(grobStamm(w)))
-                getroffen += g;
-        }
-        return gesamt > 0 ? getroffen / gesamt : 0;
-    }
-}
-/** Auf 0 bis 1 spreizen — innerhalb des Topfes, nicht über den Bestand. */
-export function spreizeImTopf(werte) {
-    const gueltig = werte.filter((x) => Number.isFinite(x) && x > -2);
-    if (gueltig.length === 0)
-        return werte.map(() => 0);
-    let min = Infinity;
-    let max = -Infinity;
-    for (const x of gueltig) {
-        if (x < min)
-            min = x;
-        if (x > max)
-            max = x;
-    }
-    if (max === min)
-        return werte.map(() => 0.5);
-    return werte.map((x) => (x > -2 ? (x - min) / (max - min) : 0));
-}
-/**
- * Die Frage mit ihren besten Treffern anreichern.
- *
- * Die Frage benutzt Alltagsworte, die Lektionen Fachworte. Die ersten Treffer
- * schlagen diese Brücke: ihre Vektoren zeigen dorthin, wo die Antwort liegt.
- *
- * Das Risiko ist bekannt und begrenzt: sind die ersten Treffer falsch, zieht
- * die Anreicherung in die falsche Richtung. Deshalb bleibt die ursprüngliche
- * Frage mit drei Vierteln stehen — gemessen war das besser als jede stärkere
- * Beimischung.
- */
-export function reichereAn(frage, besteTreffer, anteil = 0.25) {
-    if (besteTreffer.length === 0)
-        return frage;
-    const d = frage.length;
-    const m = new Array(d).fill(0);
-    for (const v of besteTreffer) {
-        if (v.length !== d)
-            continue;
-        for (let i = 0; i < d; i++)
-            m[i] += v[i] / besteTreffer.length;
-    }
-    return frage.map((x, i) => (1 - anteil) * x + anteil * m[i]);
-}
-/**
- * Die Gewichte.
- *
- * Kreuzweise ermittelt: auf der einen Hälfte der Fragen eingestellt, auf der
- * anderen gemessen, in beide Richtungen. Die drei Werte hier waren in BEIDEN
- * Richtungen stabil. Zwei weitere Merkmale — Überlappung mit dem Themennamen
- * und Qualitätsmerkmale — schwankten zwischen den Richtungen und sind deshalb
- * NICHT dabei: was nur in einer Hälfte hilft, ist eine Eigenschaft dieser
- * Hälfte, keine des Verfahrens.
- */
-export const GEWICHTE = {
-    /** Nähe zum ganzen Text. Der Grundstock, deshalb 1. */
-    text: 1,
-    /** Nähe zum Themennamen. In beiden Richtungen 0,6. */
-    thema: 0.6,
-    /** Angereicherte Frage gegen den ganzen Text. In beiden Richtungen 0,3. */
-    rueckkopplung: 0.3,
-    /** Anteil der seltenen Fragewörter im Text. 1,0 bis 1,6 — Mitte genommen. */
-    seltenheit: 1.3,
-};
-/**
- * Punktzahl je Kandidat. Höher ist besser.
- *
- * Erwartet den GANZEN Topf auf einmal, weil die Normierung ihn braucht — eine
- * Punktzahl für einen einzelnen Kandidaten gibt es nicht und kann es nicht
- * geben.
- */
-export function bewerteTopf(topf, gewichte = GEWICHTE) {
-    const t = spreizeImTopf(topf.map((k) => k.naeheText));
-    const th = spreizeImTopf(topf.map((k) => k.naeheThema));
-    const r = spreizeImTopf(topf.map((k) => k.naeheRueckkopplung));
-    return topf.map((k, i) => gewichte.text * t[i]
-        + gewichte.thema * th[i]
-        + gewichte.rueckkopplung * r[i]
-        + gewichte.seltenheit * k.seltenheitsDeckung);
-}
-/**
- * Punktzahl je Kandidat — STRENGE Fassung: Merkmale multiplizieren statt addieren.
- *
- * ── Das Vorbild ─────────────────────────────────────────────────────────────
- *
- * Kinetisches Korrekturlesen (Hopfield 1974, T-Zell-Rezeptoren): Biochemie
- * erreicht Fehlerraten weit unter dem, was ein einzelner Bindungsschritt
- * hergibt, indem sie Kandidaten durch eine KETTE von Pruefschritten schickt.
- * Bei jedem Schritt kann der Kandidat abfallen; die Trennschaerfe der Schritte
- * MULTIPLIZIERT sich, statt sich zu mitteln.
- *
- * ── Der Unterschied zur Addition ────────────────────────────────────────────
- *
- * In der Summe (bewerteTopf) kann ein Kandidat totale Schwaeche in einem
- * Merkmal mit Staerke in einem anderen voll ausgleichen. Im Produkt nicht:
- * eine Null in einem Merkmal drueckt die Gesamtnote, egal wie gut der Rest
- * ist. Das Produkt verlangt STIMMIGKEIT ueber alle Merkmale — die Summe
- * verlangt nur Masse.
- *
- * `basis` stellt die Strenge ein: grosse Basis naehert sich der Summe an,
- * kleine Basis macht eine Null toedlich. Rechnerisch ist das eine gewichtete
- * Summe im Logarithmus — der Unterschied zur Addition ist die begrenzte
- * Ausgleichbarkeit, nicht die Buchhaltung.
- *
- * Ergebnis der Messung vom 21.08.2026 steht in src/bench/fusion-vergleich.ts.
- */
-export function bewerteTopfStreng(topf, gewichte = GEWICHTE, basis = 0.3) {
-    const t = spreizeImTopf(topf.map((k) => k.naeheText));
-    const th = spreizeImTopf(topf.map((k) => k.naeheThema));
-    const r = spreizeImTopf(topf.map((k) => k.naeheRueckkopplung));
-    return topf.map((k, i) => gewichte.text * Math.log(basis + t[i])
-        + gewichte.thema * Math.log(basis + th[i])
-        + gewichte.rueckkopplung * Math.log(basis + r[i])
-        + gewichte.seltenheit * Math.log(basis + k.seltenheitsDeckung));
-}
-/** Bequemlichkeit: Kosinus mit Lücken-Behandlung. */
-export function naeheOderLuecke(frage, vektor) {
-    return frage && vektor && vektor.length > 0 ? kosinus(frage, vektor) : -2;
-}
-//# sourceMappingURL=rangfolge.js.map
+import{kosinus as i}from"./bedeutung.js";function p(n){return new Set(n.toLowerCase().replace(/ä/g,"ae").replace(/ö/g,"oe").replace(/ü/g,"ue").replace(/ß/g,"ss").split(/[^a-z0-9]+/).filter(e=>e.length>3))}function g(n){return n}class m{df=new Map;anzahl=0;constructor(e){this.anzahl=e.length;for(const s of e)for(const r of p(s))this.df.set(r,(this.df.get(r)??0)+1)}wert(e){return Math.log((this.anzahl+1)/((this.df.get(e)??0)+1))}deckung(e,s){let r=0,l=0;for(const a of e){const o=this.wert(a);r+=o,s.has(a)&&(l+=o)}return r>0?l/r:0}besterZeuge(e,s){let r=0;const l=Math.log(this.anzahl+1);if(l<=0)return 0;for(const a of e){if(!s.has(a))continue;const o=this.wert(a)/l;o>r&&(r=o)}return r}}function u(n){const e=n.filter(t=>Number.isFinite(t)&&t>-2);if(e.length===0)return n.map(()=>0);let s=1/0,r=-1/0;for(const t of e)t<s&&(s=t),t>r&&(r=t);if(r===s)return n.map(()=>.5);const l=n.map(t=>Number.isFinite(t)&&t>-2?(t-s)/(r-s):-1);let a=0;for(const t of l)t>=0&&(a+=t);const o=a/e.length;return l.map(t=>t>=0?t:o)}function k(n,e,s=.25){if(e.length===0)return n;const r=n.length,l=new Array(r).fill(0);for(const a of e)if(a.length===r)for(let o=0;o<r;o++)l[o]+=a[o]/e.length;return n.map((a,o)=>(1-s)*a+s*l[o])}const c={text:1,thema:0,rueckkopplung:.3,seltenheit:1.3,zeuge:.5};function x(n,e=c){const s=u(n.map(t=>t.naeheText)),r=u(n.map(t=>t.naeheThema)),l=u(n.map(t=>t.naeheRueckkopplung)),a=u(n.map(t=>t.besterZeuge??0)),o=e.zeuge??0;return n.map((t,h)=>e.text*s[h]+e.thema*r[h]+e.rueckkopplung*l[h]+e.seltenheit*t.seltenheitsDeckung+o*a[h])}function z(n,e=c,s=.3){const r=u(n.map(o=>o.naeheText)),l=u(n.map(o=>o.naeheThema)),a=u(n.map(o=>o.naeheRueckkopplung));return n.map((o,t)=>e.text*Math.log(s+r[t])+e.thema*Math.log(s+l[t])+e.rueckkopplung*Math.log(s+a[t])+e.seltenheit*Math.log(s+o.seltenheitsDeckung))}function d(n,e){return n&&e&&e.length>0?i(n,e):-2}export{c as GEWICHTE,m as Seltenheit,x as bewerteTopf,z as bewerteTopfStreng,g as grobStamm,p as inhaltsWoerter,d as naeheOderLuecke,k as reichereAn,u as spreizeImTopf};

package/dist/src/raumkorrektur.js

@@ -1,197 +1 @@
-/**
- * Raumkorrektur: den Einbettungsraum brauchbar machen, bevor man darin sucht.
- *
- * ── Drei Übel, drei Gegenmittel ─────────────────────────────────────────────
- *
- * Ein Einbettungsraum ist nicht neutral. Er hat Eigenschaften, die das Sortieren
- * verderben — alle drei am 19.08.2026 an 499 echten Lektionen gemessen:
- *
- * 1. GEMEINSAME GRUNDRICHTUNG (Anisotropie). Ein durchschnittlicher Vektor
- *    zeigt zu 69,8 Prozent in Richtung des Schwerpunkts aller Vektoren. Dieser
- *    Anteil ist in JEDEM Vergleich derselbe und sagt daher nichts — er hebt nur
- *    alle Werte an und drückt die Unterschiede zusammen. Gemessen liegen alle
- *    Ähnlichkeiten zwischen 0,42 und 0,61.
- *
- * 2. RICHTUNGEN, DIE NUR SCHREIBSTIL SIND. Nach dem Schwerpunkt bleiben ein
- *    paar Hauptrichtungen übrig, die keine Bedeutung tragen, sondern Textsorte:
- *    "ist eine Fehlermeldung", "enthält Codeschnipsel", "ist auf Deutsch".
- *    Sie sind stark und lenken die Rangfolge.
- *
- * 3. NABEN. Manche Vektoren liegen einfach nahe an vielem. Sie erscheinen als
- *    Treffer für Fragen, mit denen sie nichts zu tun haben. Belegt: die Lektion
- *    `forge:arbeitskopie-nach-dem-merge-sofort-abraeumen` stand bei "Ich beende
- *    den Prozess, kurz darauf ist er neu da" UND bei "Wenn der Zwischenspeicher
- *    abläuft, schlagen alle Anfragen durch" auf Platz 1. Zwei Fragen ohne
- *    Berührungspunkt, dieselbe falsche Antwort.
- *
- * ── Die Gegenmittel ─────────────────────────────────────────────────────────
- *
- * Zu 1 und 2: Schwerpunkt abziehen und die stärksten verbleibenden
- * Hauptrichtungen entfernen. Was danach übrig bleibt, ist das, worin sich die
- * Texte inhaltlich unterscheiden.
- *
- * Zu 3: jedem Vektor seine eigene "Geselligkeit" ausrechnen — wie nah liegt er
- * im Mittel an seinen nächsten Nachbarn. Wer überall nah dran ist, bekommt
- * einen Abzug. Das ist die Idee hinter CSLS aus der Wortübersetzung, hier auf
- * den Fall übertragen, dass zur Bauzeit keine Fragen vorliegen: die Nachbarn
- * sind die anderen Lektionen.
- *
- * Entscheidend für den Betrieb: ALLES DAVON WIRD EINMAL AUSGERECHNET. Zur
- * Fragezeit bleibt ein Skalarprodukt und eine Subtraktion. Die Rangfolge wird
- * besser, ohne dass jemand länger wartet.
- */
-/** Skalarprodukt. */
-export function punktprodukt(a, b) {
-    let s = 0;
-    for (let i = 0; i < a.length; i++)
-        s += a[i] * b[i];
-    return s;
-}
-export function laenge(v) {
-    return Math.sqrt(punktprodukt(v, v));
-}
-/** Auf Länge 1 bringen. Ein Nullvektor bleibt, was er ist. */
-export function normiere(v) {
-    const l = laenge(v);
-    return l > 1e-12 ? v.map((x) => x / l) : v.slice();
-}
-/** Der Schwerpunkt — die gemeinsame Grundrichtung aller Vektoren. */
-export function schwerpunkt(vs) {
-    const d = vs[0]?.length ?? 0;
-    const m = new Array(d).fill(0);
-    for (const v of vs)
-        for (let i = 0; i < d; i++)
-            m[i] += v[i];
-    for (let i = 0; i < d; i++)
-        m[i] /= Math.max(1, vs.length);
-    return m;
-}
-/**
- * Die stärksten Hauptrichtungen, über Potenziteration mit Deflation.
- *
- * Warum von Hand statt einer Bibliothek: es sind rund zwanzig Zeilen, läuft
- * einmal, und eine Abhängigkeit für zwanzig Zeilen ist eine Abhängigkeit, die
- * jemand pflegen muss.
- *
- * Die Vektoren müssen bereits zentriert sein — sonst ist die erste
- * Hauptrichtung nur der Schwerpunkt, den wir gerade abgezogen haben.
- */
-export function hauptrichtungen(zentriert, anzahl, schritte = 30) {
-    const d = zentriert[0]?.length ?? 0;
-    const rest = zentriert.map((v) => v.slice());
-    const aus = [];
-    for (let k = 0; k < anzahl; k++) {
-        // Startvektor: fest, nicht zufällig — sonst liefert derselbe Bestand bei
-        // jedem Lauf leicht andere Richtungen, und niemand kann eine Messung
-        // wiederholen.
-        let u = new Array(d).fill(0).map((_, i) => Math.sin(i * (k + 1) * 0.7));
-        u = normiere(u);
-        for (let s = 0; s < schritte; s++) {
-            const neu = new Array(d).fill(0);
-            for (const v of rest) {
-                const p = punktprodukt(v, u);
-                for (let i = 0; i < d; i++)
-                    neu[i] += p * v[i];
-            }
-            const l = laenge(neu);
-            if (l < 1e-12)
-                break;
-            for (let i = 0; i < d; i++)
-                neu[i] /= l;
-            u = neu;
-        }
-        aus.push(u);
-        // Deflation: den gefundenen Anteil aus allen Vektoren entfernen, damit die
-        // nächste Iteration eine ANDERE Richtung findet.
-        for (const v of rest) {
-            const p = punktprodukt(v, u);
-            for (let i = 0; i < d; i++)
-                v[i] -= p * u[i];
-        }
-    }
-    return aus;
-}
-/** Was von einem Vektor bleibt, wenn Schwerpunkt und Hauptrichtungen weg sind. */
-export function bereinige(v, mitte, richtungen) {
-    const w = v.map((x, i) => x - mitte[i]);
-    for (const u of richtungen) {
-        const p = punktprodukt(w, u);
-        for (let i = 0; i < w.length; i++)
-            w[i] -= p * u[i];
-    }
-    return normiere(w);
-}
-/**
- * Die "Geselligkeit" jedes Vektors: mittlere Ähnlichkeit zu seinen k nächsten
- * Nachbarn im selben Bestand.
- *
- * Ein hoher Wert heißt: dieser Vektor liegt in einer dichten Gegend und ist
- * vielem nah. Solche Naben erscheinen als Treffer für Fragen, mit denen sie
- * nichts zu tun haben — nicht weil sie passen, sondern weil sie überall
- * passen.
- *
- * Der Wert wird EINMAL berechnet und beim Suchen abgezogen. Kosten zur
- * Fragezeit: eine Subtraktion.
- */
-export function geselligkeit(normierte, k = 10) {
-    const n = normierte.length;
-    const aus = new Array(n).fill(0);
-    for (let i = 0; i < n; i++) {
-        // Die k besten Ähnlichkeiten sammeln, ohne alles zu sortieren.
-        const beste = [];
-        for (let j = 0; j < n; j++) {
-            if (i === j)
-                continue;
-            const s = punktprodukt(normierte[i], normierte[j]);
-            if (beste.length < k) {
-                beste.push(s);
-                if (beste.length === k)
-                    beste.sort((a, b) => a - b);
-            }
-            else if (s > beste[0]) {
-                beste[0] = s;
-                beste.sort((a, b) => a - b);
-            }
-        }
-        aus[i] = beste.length ? beste.reduce((a, b) => a + b, 0) / beste.length : 0;
-    }
-    return aus;
-}
-export function baueRaum(roh, optionen = {}) {
-    const anzahlRichtungen = optionen.richtungen ?? 3;
-    const nachbarn = optionen.nachbarn ?? 10;
-    const beta = optionen.beta ?? 0.5;
-    const da = roh.filter(Boolean);
-    const mitte = schwerpunkt(da);
-    const zentriert = da.map((v) => v.map((x, i) => x - mitte[i]));
-    const richtungen = anzahlRichtungen > 0 ? hauptrichtungen(zentriert, anzahlRichtungen) : [];
-    // Bereinigte Vektoren in der ursprünglichen Reihenfolge — Lücken bleiben
-    // Lücken, damit ein fehlender Vektor nicht still zu einem Nullvektor wird,
-    // der zu allem gleich weit entfernt ist.
-    const vektoren = [];
-    const gueltigeIndizes = [];
-    for (const [i, v] of roh.entries()) {
-        if (!v) {
-            vektoren.push([]);
-            continue;
-        }
-        vektoren.push(bereinige(v, mitte, richtungen));
-        gueltigeIndizes.push(i);
-    }
-    const abzug = new Array(roh.length).fill(0);
-    const nurGueltige = gueltigeIndizes.map((i) => vektoren[i]);
-    const g = geselligkeit(nurGueltige, nachbarn);
-    gueltigeIndizes.forEach((idx, k) => { abzug[idx] = g[k]; });
-    return { mitte, richtungen, vektoren, abzug, beta };
-}
-/**
- * Bewertet eine Frage gegen alle Lektionen des Raums.
- *
- * `2 * cos - abzug` ist die Form aus CSLS. Der Faktor 2 sorgt dafür, dass der
- * Abzug die Ähnlichkeit dämpft und nicht überstimmt.
- */
-export function bewerteImRaum(raum, frage) {
-    const f = bereinige(frage, raum.mitte, raum.richtungen);
-    return raum.vektoren.map((v, i) => v.length === 0 ? -2 : 2 * punktprodukt(f, v) - raum.beta * raum.abzug[i]);
-}
-//# sourceMappingURL=raumkorrektur.js.map
+function b(t,o){let r=0;for(let n=0;n<t.length;n++)r+=t[n]*o[n];return r}function x(t){return Math.sqrt(b(t,t))}function w(t){const o=x(t);return o>1e-12?t.map(r=>r/o):t.slice()}function y(t){const o=t[0]?.length??0,r=new Array(o).fill(0);for(const n of t)for(let e=0;e<o;e++)r[e]+=n[e];for(let n=0;n<o;n++)r[n]/=Math.max(1,t.length);return r}function A(t,o,r=30){const n=t[0]?.length??0,e=t.map(c=>c.slice()),s=[];for(let c=0;c<o;c++){let i=new Array(n).fill(0).map((f,l)=>Math.sin(l*(c+1)*.7));i=w(i);for(let f=0;f<r;f++){const l=new Array(n).fill(0);for(const a of e){const m=b(a,i);for(let g=0;g<n;g++)l[g]+=m*a[g]}const u=x(l);if(u<1e-12)break;for(let a=0;a<n;a++)l[a]/=u;i=l}s.push(i);for(const f of e){const l=b(f,i);for(let u=0;u<n;u++)f[u]-=l*i[u]}}return s}function k(t,o,r){const n=t.map((e,s)=>e-o[s]);for(const e of r){const s=b(n,e);for(let c=0;c<n.length;c++)n[c]-=s*e[c]}return w(n)}function z(t,o=10){const r=t.length,n=new Array(r).fill(0);for(let e=0;e<r;e++){const s=[];for(let c=0;c<r;c++){if(e===c)continue;const i=b(t[e],t[c]);s.length<o?(s.push(i),s.length===o&&s.sort((f,l)=>f-l)):i>s[0]&&(s[0]=i,s.sort((f,l)=>f-l))}n[e]=s.length?s.reduce((c,i)=>c+i,0)/s.length:0}return n}function M(t,o={}){const r=o.richtungen??3,n=o.nachbarn??10,e=o.beta??.5,s=t.filter(Boolean),c=y(s),i=s.map(h=>h.map((p,d)=>p-c[d])),f=r>0?A(i,r):[],l=[],u=[];for(const[h,p]of t.entries()){if(!p){l.push([]);continue}l.push(k(p,c,f)),u.push(h)}const a=new Array(t.length).fill(0),m=u.map(h=>l[h]),g=z(m,n);return u.forEach((h,p)=>{a[h]=g[p]}),{mitte:c,richtungen:f,vektoren:l,abzug:a,beta:e}}function R(t,o){const r=k(o,t.mitte,t.richtungen);return t.vektoren.map((n,e)=>n.length===0?-2:2*b(r,n)-t.beta*t.abzug[e])}export{M as baueRaum,k as bereinige,R as bewerteImRaum,z as geselligkeit,A as hauptrichtungen,x as laenge,w as normiere,b as punktprodukt,y as schwerpunkt};

package/dist/src/recall-tiefe.js

@@ -1,42 +1 @@
-/**
- * Wie viele Treffer zeigt `smart_recall` — und wie viele haelt es zurueck?
- *
- * Eigenes Modul, weil hier ein Versprechen eingeloest wird, das vorher nur im
- * Kommentar stand. Der Kommentar am Teaser-Gate sagte seit jeher:
- *
- *   "the magic moment is sacred ... never an access wall: the #1 result is
- *    always returned"
- *
- * Der Code sagte `visibleCount = gateActive ? 0 : 8` — also NULL Treffer,
- * sobald ein Frei-Konto sein Monatskontingent ueberschritten hat. Der Nutzer
- * las die Ueberschrift "Results (23 — hybrid)", darunter keine einzige Zeile
- * und dann eine Kaufaufforderung. Das sieht nicht aus wie eine Rechnung,
- * sondern wie ein kaputtes Werkzeug — besonders bei Ambient Recall, das bei
- * jedem Prompt feuert und das Kontingent in Tagen aufbraucht.
- *
- * Fehlerklasse: eine Zusage an zwei Orten gepflegt (Kommentar und Zweig).
- * Deshalb ist die Regel jetzt eine Funktion mit Tests, nicht ein Satz Prosa.
- */
-/** Der eine Treffer, den auch ein ueberzogenes Frei-Konto immer sieht. */
-export const TIEFE_UEBER_LIMIT = 1;
-/** Volle Tiefe bei einer einzelnen Frage. */
-export const TIEFE_VOLL = 8;
-/** Volle Tiefe, wenn die Frage in Unterfragen zerfaellt (mehr Themen, mehr Platz). */
-export const TIEFE_VOLL_MEHRTHEMIG = 12;
-/**
- * Nie eine Mauer, immer eine Bremse: ueber dem Limit bleibt genau der beste
- * Treffer sichtbar, der Rest wird gezaehlt und benannt.
- *
- * Bei null Treffern gibt es nichts zu zeigen und nichts zurueckzuhalten — ein
- * leeres Ergebnis darf nie als "hinter der Bezahlschranke" erscheinen, sonst
- * verkauft die Meldung etwas, das gar nicht existiert.
- */
-export function recallTiefe({ ueberLimit, gesamt, volleTiefe = TIEFE_VOLL }) {
-    const vorhanden = Number.isFinite(gesamt) && gesamt > 0 ? Math.floor(gesamt) : 0;
-    if (vorhanden === 0)
-        return { sichtbar: 0, zurueckgehalten: 0 };
-    const obergrenze = ueberLimit ? TIEFE_UEBER_LIMIT : Math.max(0, Math.floor(volleTiefe));
-    const sichtbar = Math.min(vorhanden, obergrenze);
-    return { sichtbar, zurueckgehalten: ueberLimit ? vorhanden - sichtbar : 0 };
-}
-//# sourceMappingURL=recall-tiefe.js.map
+const c=1,I=8,a=12;function h({ueberLimit:e,gesamt:t,volleTiefe:o=8}){const r=Number.isFinite(t)&&t>0?Math.floor(t):0;if(r===0)return{sichtbar:0,zurueckgehalten:0};const E=e?1:Math.max(0,Math.floor(o)),n=Math.min(r,E);return{sichtbar:n,zurueckgehalten:e?r-n:0}}export{c as TIEFE_UEBER_LIMIT,I as TIEFE_VOLL,a as TIEFE_VOLL_MEHRTHEMIG,h as recallTiefe};

package/dist/src/rerank.js

@@ -1,154 +1 @@
-/**
- * Quality-aware reranking for Brain recall.
- *
- * The raw BM25+ keyword search (src/search.ts) ranks purely by *textual* relevance.
- * That is necessary but not sufficient: when an agent asks "how do I fix the flaky
- * deploy?", a *failed* attempt with similar words can out-rank the *proven success*
- * lesson that actually solves it. Anthropic's flat-file memory has exactly this
- * problem — it reads files in order, with no notion of which lesson is trustworthy.
- *
- * This module is Cachly's structural advantage made concrete: we re-rank text
- * matches by the *quality* of the underlying lesson — outcome, confidence,
- * proven-ness (recall_count), severity and human review (endorsements) — so the
- * lesson most likely to help surfaces first. A flat-file memory has none of these
- * signals; a senior-confirmed, ten-times-recalled success reads identically to a
- * one-off failed attempt.
- *
- * It is intentionally pure (no I/O): the lesson JSON already travels inside each
- * KeywordMatch.content for `cachly:lesson:best:*` keys, so reranking needs no extra
- * Redis round-trips. This keeps it fast and trivially benchmarkable (see
- * src/bench/cachly-bench.ts).
- */
-import { safeJsonParse } from './utils.js';
-// ── Tunable weights (kept conservative; validated by Cachly-Bench) ─────────────
-const OUTCOME_WEIGHT = {
-    success: 1.0,
-    partial: 0.8,
-    failure: 0.55,
-};
-const OUTCOME_DEFAULT = 0.75; // unknown / not a lesson with an outcome
-const SEVERITY_WEIGHT = {
-    critical: 1.15,
-    major: 1.05,
-    minor: 1.0,
-};
-const SEVERITY_DEFAULT = 1.0;
-// Governance: a human-confirmed lesson is more trustworthy than one proven only
-// by automated recall. A senior review weighs more than a peer review; multiple
-// endorsements add a small, saturating bump on top.
-const REVIEW_LEVEL_WEIGHT = {
-    senior: 1.25,
-    peer: 1.1,
-};
-// Clamp so a strong text match is never fully buried by quality, and a weak text
-// match is never catapulted to the top purely on quality.
-// MAX lowered 2.5→1.8: on larger corpora a high-quality but weakly-matching lesson
-// could overtake a strongly-matching relevant one and push it out of the top-k.
-// 1.8 keeps the home-corpus Precision@1 lift while improving external-corpus
-// Precision@1 + MRR (validated by src/bench/external-corpus.ts).
-const MIN_MULTIPLIER = 0.5;
-const MAX_MULTIPLIER = 1.8;
-const LESSON_KEY_PREFIX = 'cachly:lesson:best:';
-/**
- * Compute the quality multiplier for a single lesson.
- * Returns 1.0 (neutral) for documents that carry no quality signal (e.g. context).
- */
-export function qualityMultiplier(lesson) {
-    if (!lesson || (lesson.outcome === undefined && lesson.confidence === undefined
-        && lesson.recall_count === undefined && lesson.reviewed_by === undefined
-        && lesson.endorsements === undefined)) {
-        return 1.0;
-    }
-    // 1. Outcome — a proven success is what the agent actually wants.
-    const outcome = OUTCOME_WEIGHT[lesson.outcome ?? ''] ?? OUTCOME_DEFAULT;
-    // 2. Confidence — maps 0..1 → 0.7..1.3 so it nudges, not dominates.
-    const conf = typeof lesson.confidence === 'number' ? Math.max(0, Math.min(1, lesson.confidence)) : 0.6;
-    const confidenceFactor = 0.7 + 0.6 * conf;
-    // 3. Proven-ness — a lesson recalled many times has stood the test of use.
-    //    Log-scaled so it saturates: rc=0→1.0, rc=5→~1.18, rc=50→~1.30.
-    const rc = Math.max(0, lesson.recall_count ?? 0);
-    const provenBoost = 1 + Math.min(0.3, Math.log1p(rc) / 13);
-    // 4. Severity — when two lessons tie, surface the one guarding the worse failure.
-    const severity = SEVERITY_WEIGHT[lesson.severity ?? ''] ?? SEVERITY_DEFAULT;
-    // 5. Governance — a human-confirmed lesson outranks an unreviewed one.
-    //    Base weight from the review level, plus a small saturating bump for
-    //    additional endorsements (rc-style log curve, capped at +0.1).
-    const reviewBase = lesson.reviewed_by
-        ? (REVIEW_LEVEL_WEIGHT[lesson.review_level ?? 'peer'] ?? REVIEW_LEVEL_WEIGHT.peer)
-        : 1.0;
-    const extraEndorse = Math.max(0, (lesson.endorsements ?? 0) - 1);
-    const reviewBoost = reviewBase * (1 + Math.min(0.1, Math.log1p(extraEndorse) / 20));
-    const m = outcome * confidenceFactor * provenBoost * severity * reviewBoost;
-    return Math.max(MIN_MULTIPLIER, Math.min(MAX_MULTIPLIER, m));
-}
-/** Extract the quality signal from a match, if its content is a stored lesson. */
-export function extractLessonQuality(match) {
-    if (!match.key.startsWith(LESSON_KEY_PREFIX))
-        return null;
-    return safeJsonParse(match.content, null);
-}
-/**
- * Rerank BM25 keyword matches by lesson quality.
- *
- * BM25 scores are compressed with a 0.3-power root before quality is applied.
- * Compression is the key: a distractor lesson whose `what_failed` contains the
- * exact query phrase can score 5–6× higher in BM25 than the correct success lesson.
- * A linear quality multiplier of ±40% cannot overcome that gap; after ^0.3
- * compression the ratio shrinks to ~1.5×, well within the quality range.
- *
- * The formula  compressed_score * (0.4 + 0.6 * boost)  gives quality 60% weight
- * on the compressed axis. A failure lesson (boost ≈ 0.5) retains 70% of its
- * compressed score; a senior-confirmed success (boost ≈ 1.8) gets 148%.
- * Ties are broken by the raw BM25 score (stable, deterministic).
- */
-/**
- * Wie stark Qualitaetsmerkmale die Rangfolge bewegen duerfen.
- *
- * Bleibt bei 0.6 — dem Wert von vorher. Die Messreihe vom 19.08.2026 zeigt,
- * dass dieser Wert auf echten Daten NICHTS kostet: bei ungestauchter Relevanz
- * liefern 0.6, 0.3 und 0.15 dasselbe Ergebnis (30 Prozent auf Platz 1).
- *
- * Das ist der Grund, hier nichts zu aendern. Der Schaden kam allein von der
- * Stauchung darunter. Wer zwei Dinge gleichzeitig verstellt, weiss hinterher
- * nicht, welches gewirkt hat.
- */
-const QUALITAETS_GEWICHT = 0.6;
-export function rerankByQuality(matches) {
-    if (matches.length === 0)
-        return [];
-    const reranked = matches.map(m => {
-        // ── Die Relevanz wird NICHT mehr plattgedrueckt ─────────────────────────
-        //
-        // Hier stand `Math.pow(score, 0.3)`. Das war Absicht: die Relevanz wurde
-        // zusammengestaucht, damit die Qualitaetsmerkmale (Zuversicht, Abnahme,
-        // Zustimmungen) die Rangfolge mitbestimmen koennen. Aus einem
-        // zehnfachen Relevanzvorsprung wurde ein doppelter.
-        //
-        // Auf dem Pruefstand mit 17 Lektionen war das ein Gewinn: 92,3 statt
-        // 69,2 Prozent. Genau diese Zahl steht seit Monaten auf der Landingpage.
-        //
-        // Auf 498 echten Lektionen, am 19.08.2026 gemessen, ist es der Verlust:
-        //
-        //   Stauchung   echter Bestand   Pruefstand
-        //   ^0.3            15 %            92,3 %
-        //   ^0.6            25 %            76,9 %
-        //   ^1.0 (keine)    30 %            69,2 %
-        //
-        // Der gesamte gemessene Vorteil auf dem Pruefstand IST der Schaden auf
-        // echten Daten. Bei 17 Lektionen ist der richtige Treffer so eindeutig,
-        // dass er auch gestaucht gewinnt. Bei 498 ist die Relevanz das knappe
-        // Gut, und wer sie staucht, wirft weg, was er hat.
-        const compressed = Math.max(0, m.score);
-        const lesson = extractLessonQuality(m);
-        const boost = qualityMultiplier(lesson);
-        // Qualitaet wirkt unveraendert auf die UNGESTAUCHTE Relevanz. Damit kann
-        // sie einen knappen Textvorsprung noch drehen (eine belegte Loesung schlaegt
-        // einen etwas besser passenden Fehlversuch), einen deutlichen aber nicht
-        // mehr.
-        const finalScore = compressed * (1 - QUALITAETS_GEWICHT + QUALITAETS_GEWICHT * boost);
-        return { ...m, finalScore, qualityBoost: boost };
-    });
-    reranked.sort((a, b) => (b.finalScore - a.finalScore) || (b.score - a.score));
-    return reranked;
-}
-//# sourceMappingURL=rerank.js.map
+import{safeJsonParse as m}from"./utils.js";const M={success:1,partial:.8,failure:.55},_=.75,l={critical:1.15,major:1.05,minor:1},p=1,a={senior:1.25,peer:1.1},I=.5,T=1.8,h="cachly:lesson:best:";function y(e){if(!e||e.outcome===void 0&&e.confidence===void 0&&e.recall_count===void 0&&e.reviewed_by===void 0&&e.endorsements===void 0)return 1;const o=M[e.outcome??""]??_,n=.7+.6*(typeof e.confidence=="number"?Math.max(0,Math.min(1,e.confidence)):.6),c=Math.max(0,e.recall_count??0),r=1+Math.min(.3,Math.log1p(c)/13),i=l[e.severity??""]??p,u=e.reviewed_by?a[e.review_level??"peer"]??a.peer:1,f=Math.max(0,(e.endorsements??0)-1),E=u*(1+Math.min(.1,Math.log1p(f)/20)),d=o*n*r*i*E;return Math.max(I,Math.min(T,d))}function L(e){return e.key.startsWith(h)?m(e.content,null):null}const s=.6;function v(e){if(e.length===0)return[];const o=e.map(t=>{const n=Math.max(0,t.score),c=L(t),r=y(c),i=n*(1-s+s*r);return{...t,finalScore:i,qualityBoost:r}});return o.sort((t,n)=>n.finalScore-t.finalScore||n.score-t.score),o}export{L as extractLessonQuality,y as qualityMultiplier,v as rerankByQuality};