@futdevpro/fdp-agent-memory 1.1.166 → 1.1.194

package/build/src/_modules/retrieval/_collections/fam-memory-retention.util.js

@@ -0,0 +1,70 @@
+"use strict";
+/**
+ * MEMÓRIA-RETENCIÓ — az alvó beszélgetés-törmelék nyugdíjazásának döntési logikája (2026-09-02).
+ *
+ * **A probléma (mérve).** Az aktív `memory` tár 20,2%-a (8 717 bejegyzés) nyers user-prompt
+ * (`kind: user_prompt` / `tags: [temporary_context]`) — egy egyszeri, 2026-06-os claude-mem import
+ * hagyatéka (azóta 4 új keletkezett, tehát NINCS élő csap). **98,2%-uk soha nem lett felidézve**, mégis
+ * teljes súllyal versenyeznek a gondozott jegyzetekkel a nyers koszinusz-rangsorban — és mivel rövidek
+ * és tematikusak, gyakran nyernek is.
+ *
+ * **A szabály (v2, owner: „javítsd, amit kell" — 2026-09-02):** a törmelék-osztály 30+ nap után nyugdíjba
+ * vonul, a felidézés-számtól FÜGGETLENÜL.
+ *
+ * **Miért nem véd a `recallCount` ezen az osztályon — mérve.** Az első változat a „amit többet használtunk,
+ * az tovább él" elv szerint kivételezett a valaha felidézettekkel (164 túlélő). Az audit ezt megbuktatta:
+ * a legtöbbet „felidézett" túlélők **gépi zaj** voltak — `<task-notification>` és `<ide_opened_file>`
+ * XML-blokkok, recall=281-gyel a csúcson (67/164 tisztán ilyen; a maradék átirat-üledék: „Látod", „Azt",
+ * build-logok). A felidézés AUTOMATIKUS (minden visszaadott találat recallCount++-t kap), így ezen az
+ * osztályon a szám a RANGSOR-KITETTSÉGET méri, nem a használatot — és öngerjesztő: ami magasra rangsorol,
+ * azt a visszaadás „felidézi", amitől védetté válik. Az owner elve a MEMÓRIÁKRA vonatkozik; a nyers
+ * átirat-törmelék nem az. A nyugdíj ettől még NEM törlés: minden hidegen kereshető marad, és
+ * visszafordítható — a genuinly hasznos darab a cold-search-ben él, vagy gondozott bejegyzésként újraírható.
+ *
+ * Ugyanezen mérés miatt a REAKTIVÁCIÓ is kihagyja ezt az osztályt (`selectMemoryIds` szűrője) — a hurok
+ * motorja leállt: a törmelék többé nem tud „használtnak" látszani attól, hogy előkerül.
+ *
+ * **A nyugdíj NEM törlés:** `superseded: true` + `retiredAt` — a tartalom és a vektor a poolban marad,
+ * a `memory.supersededPenalty` (0.25) süllyeszti, a cold-search megtalálja. Visszafordítható.
+ *
+ * **Hatókör-korlátok (mind mért indokkal):**
+ *  - CSAK a törmelék-osztály (`user_prompt` / `temporary_context`) — a `session-observation` NEM az:
+ *    24%-a felidézett és ma is aktívan nő; a `memory_entry` a gondozott törzs.
+ *  - CSAK a 30+ naposak (`memory.retireTemporaryAfterDays`) — a friss kontextus a session alatt még
+ *    ténylegesen kontextus; utána üledék.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FAM_MemoryRetention_Util = void 0;
+/** A törmelék-osztály definíciója — UGYANAZ, amit a kereszt-tár szonda kizár (egy definíció, két felhasználás). */
+const DEBRIS_KINDS = ['user_prompt'];
+const DEBRIS_TAGS = ['temporary_context'];
+const DAY_MS = 24 * 60 * 60 * 1000;
+class FAM_MemoryRetention_Util {
+    /** Törmelék-osztályú-e a bejegyzés (nyers prompt / átmeneti kontextus). */
+    static isDebris(candidate) {
+        if (candidate.kind && DEBRIS_KINDS.includes(candidate.kind)) {
+            return true;
+        }
+        return (candidate.tags ?? []).some((tag) => DEBRIS_TAGS.includes(tag));
+    }
+    /**
+     * A döntés egyetlen bejegyzésre. A sorrend a VÉDELMI sorrend: előbb a kizáró okok (nem törmelék /
+     * már nyugdíjas / túl friss), és csak ha egyik sem áll, akkor `retire`. A `recallCount` ITT SZÁNDÉKOSAN
+     * nem véd — az indoklás (mért öngerjesztő hurok) a fájl fejlécében.
+     */
+    static decide(candidate, set) {
+        if (!FAM_MemoryRetention_Util.isDebris(candidate)) {
+            return 'keep-not-debris';
+        }
+        if (candidate.superseded === true) {
+            return 'keep-already-superseded';
+        }
+        const createdAt = typeof candidate.createdAt === 'number' ? candidate.createdAt : Number.NaN;
+        // Datum nelkuli bejegyzest NEM nyugdijazunk — a hianyzo teny nem bizonyitek az oregsegre.
+        if (!Number.isFinite(createdAt) || set.now - createdAt < set.retireAfterDays * DAY_MS) {
+            return 'keep-too-young';
+        }
+        return 'retire';
+    }
+}
+exports.FAM_MemoryRetention_Util = FAM_MemoryRetention_Util;

package/build/src/_modules/retrieval/_services/fam-memory-reactivation.control-service.js

@@ -7,6 +7,7 @@ const fsm_dynamo_1 = require("@futdevpro/fsm-dynamo");
 const fam_table_type_enum_1 = require("../../../_enums/fam-table.type-enum");
 const embedding_1 = require("../../embedding");
 const fam_memory_data_model_1 = require("../../../_models/data-models/fam-memory.data-model");
+const fam_memory_retention_util_1 = require("../_collections/fam-memory-retention.util");
 /**
  * `FAM_MemoryReactivation_ControlService` (dsgn-013 §4, MAM F2) — a memória FELIDÉZÉS-megerősítése. Amikor a `read`
  * ténylegesen VISSZAAD egy `memory`-hitet (a felhasználó/agent felidézte), az „új energiát kap": `lastRecalledAt = now`,
@@ -55,7 +56,13 @@ class FAM_MemoryReactivation_ControlService {
      */
     static selectMemoryIds(hits) {
         const ids = hits
-            .filter((hit) => hit.table === fam_table_type_enum_1.FAM_Table.memory && typeof hit.id === 'string' && hit.id.length > 0)
+            .filter((hit) => hit.table === fam_table_type_enum_1.FAM_Table.memory && typeof hit.id === 'string' && hit.id.length > 0
+            // A TORMELEK-osztaly (user_prompt / temporary_context) NEM kap felidezes-megerositest
+            // (2026-09-02, mert ongerjeszto hurok): a rovid atirat-toredek magasra rangsorol -> a
+            // visszaadas automatikus recallCount++-t adott -> "hasznaltnak" latszott es a retencio
+            // vedte. A csucson recall=281 egy <task-notification> XML-blokkon. A szamlalo ezen az
+            // osztalyon a rangsor-kitettseget merte, nem a hasznalatot — a motor itt all le.
+            && !fam_memory_retention_util_1.FAM_MemoryRetention_Util.isDebris({ kind: hit.kind, tags: hit.tags }))
             .map((hit) => hit.id);
         return Array.from(new Set(ids));
     }

package/build/src/_modules/retrieval/_services/fam-memory-retention.control-service.js

@@ -0,0 +1,118 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FAM_MemoryRetention_ControlService = void 0;
+const tslib_1 = require("tslib");
+const mongoose_1 = tslib_1.__importDefault(require("mongoose"));
+const fsm_dynamo_1 = require("@futdevpro/fsm-dynamo");
+const fam_table_type_enum_1 = require("../../../_enums/fam-table.type-enum");
+const embedding_1 = require("../../embedding");
+const config_control_service_1 = require("../../../_routes/server/config/config.control-service");
+const fam_memory_retention_util_1 = require("../_collections/fam-memory-retention.util");
+/**
+ * MEMÓRIA-RETENCIÓ (2026-09-02) — az alvó beszélgetés-törmelék heti nyugdíjazása. A döntési logika és a
+ * teljes indoklás a pure utilban (`fam-memory-retention.util.ts`); ez a réteg a Mongo-munka.
+ *
+ * A nyugdíj = `superseded: true` + `retiredAt` — NEM törlés: a tartalom és a vektor a poolban marad
+ * (a `memory.supersededPenalty` süllyeszti, a cold-search megtalálja). A pool-hoz ezért NEM nyúlunk
+ * (nincs `removeVector`) — pontosan úgy, ahogy a tartalom-leváltásos `superseded` ág sem teszi.
+ *
+ * **Heti automatika:** a scan-scheduler a heti re-scan UTÁN hívja (`memory.retireTemporaryEnabled`,
+ * default true) — a retenció lényege az automatizmus, különben a törmelék sosem vonul nyugdíjba.
+ */
+class FAM_MemoryRetention_ControlService {
+    static _instance;
+    static getInstance() {
+        if (!FAM_MemoryRetention_ControlService._instance) {
+            FAM_MemoryRetention_ControlService._instance = new FAM_MemoryRetention_ControlService();
+        }
+        return FAM_MemoryRetention_ControlService._instance;
+    }
+    /** A retenció futtatása — `dryRun` esetén CSAK mér, semmit nem ír. */
+    async retire(input = {}) {
+        const dryRun = input.dryRun !== false;
+        const retireAfterDays = typeof input.retireAfterDays === 'number' && input.retireAfterDays > 0
+            ? Math.floor(input.retireAfterDays)
+            : await this.resolveRetireAfterDays();
+        const registryEntry = embedding_1.FAM_StoreRegistry_Util.getEntry(fam_table_type_enum_1.FAM_Table.memory);
+        if (!registryEntry) {
+            throw new Error('A memory tár nincs a store-registry-ben — a retenció nem futtatható.');
+        }
+        // A példányosítás regisztrálja a mongoose-modellt (a raw collection eléréséhez) — a bevett minta.
+        new embedding_1.FAM_Entry_DataService({ dataParams: registryEntry.dataParams, issuer: 'memory-retention' });
+        const collection = mongoose_1.default.models[registryEntry.dataParams.dataName]?.collection;
+        if (!collection) {
+            throw new Error('A memory collection nem elérhető — a retenció nem futtatható.');
+        }
+        // CSAK a törmelék-osztály kerül a jelölt-halmazba (a Mongo szűr, nem mi töltünk fölöslegesen) —
+        // a szűkítés a pure util definícióját tükrözi; a végső döntést bejegyzésenként a util hozza.
+        const raw = await collection.find({
+            _deleted: null,
+            $or: [{ kind: 'user_prompt' }, { tags: 'temporary_context' }],
+        }, { projection: { kind: 1, tags: 1, recallCount: 1, superseded: 1, __created: 1 } }).toArray();
+        const now = Date.now();
+        const toRetire = [];
+        let keptTooYoung = 0;
+        let alreadySuperseded = 0;
+        for (const row of raw) {
+            const candidate = {
+                id: String(row._id),
+                kind: row.kind,
+                tags: row.tags,
+                recallCount: row.recallCount,
+                superseded: row.superseded,
+                createdAt: row.__created instanceof Date ? row.__created.getTime() : undefined,
+            };
+            const verdict = fam_memory_retention_util_1.FAM_MemoryRetention_Util.decide(candidate, { now: now, retireAfterDays: retireAfterDays });
+            if (verdict === 'retire') {
+                toRetire.push(row._id);
+            }
+            else if (verdict === 'keep-too-young') {
+                keptTooYoung++;
+            }
+            else if (verdict === 'keep-already-superseded') {
+                alreadySuperseded++;
+            }
+            // `keep-not-debris` a Mongo-szűrő miatt nem fordulhat elő — ha mégis, az csendben kimarad
+            // a számlálókból, és a `scanned - összeg` eltérés jelzi a szűrő-drift-et.
+        }
+        if (!dryRun && toRetire.length) {
+            await collection.updateMany({ _id: { $in: toRetire } }, { $set: { superseded: true, retiredAt: now } });
+            fsm_dynamo_1.DyFM_Log.log(`[memory-retention] ${toRetire.length} alvo tormelek-bejegyzes nyugdijazva `
+                + `(superseded+retiredAt; ${keptTooYoung} meg fiatal — a recallCount ezen az osztalyon nem ved, `
+                + 'mert ongerjeszto rangsor-kitettseget mert).');
+        }
+        return {
+            operation: 'retire_temporary_memories',
+            dryRun: dryRun,
+            retireAfterDays: retireAfterDays,
+            scanned: raw.length,
+            retired: toRetire.length,
+            keptTooYoung: keptTooYoung,
+            alreadySuperseded: alreadySuperseded,
+        };
+    }
+    /** A `memory.retireTemporaryAfterDays` feloldása (hiba/hiány → 30 — a retenció sosem bukik configon). */
+    async resolveRetireAfterDays() {
+        try {
+            const value = (await config_control_service_1.FAM_Config_ControlService.getInstance()
+                .resolve('memory.retireTemporaryAfterDays', { table: fam_table_type_enum_1.FAM_Table.memory })).value;
+            const num = typeof value === 'number' ? value : Number(value);
+            return Number.isFinite(num) && num > 0 ? Math.floor(num) : 30;
+        }
+        catch {
+            return 30;
+        }
+    }
+    /** Engedélyezett-e a heti automatika (`memory.retireTemporaryEnabled`, default true). */
+    async isAutoEnabled() {
+        try {
+            const value = (await config_control_service_1.FAM_Config_ControlService.getInstance()
+                .resolve('memory.retireTemporaryEnabled', { table: fam_table_type_enum_1.FAM_Table.memory })).value;
+            return value !== false;
+        }
+        catch {
+            return true;
+        }
+    }
+}
+exports.FAM_MemoryRetention_ControlService = FAM_MemoryRetention_ControlService;

package/build/src/_modules/retrieval/_services/fam-retrieval-candidate.data-service.js

@@ -56,6 +56,39 @@ class FAM_RetrievalCandidate_DataService {
         filter.referenceCodes = { $in: codes };
         return this.findActiveCandidates(registryEntry, filter);
     }
+    /**
+     * SZÓ SZERINTI IDÉZET-MENTÉS (2026-09-02): a `phrase`-t szó szerint tartalmazó aktív entry-k.
+     *
+     * **Miért kell:** mérve, a bemásolt hibaüzenetet hordozó chunk BE SEM KERÜL a vektor-jelöltek közé
+     * (60 találatból 0 tartalmazta a keresett stringet) — ez recall-hiba, amit rangsorolással nem lehet
+     * javítani. A minta a FEAT-003 kód-expanzió: determinisztikus, pontos egyezés a vektor-úton KÍVÜL.
+     *
+     * **MÉRET-KAPU (kötelező):** a `content` substring-keresés NEM indexelhető → collection-scan. Mérve:
+     * `rules` 296 ms · `coding_patterns` 504 ms · `knowledge` 2,1 s · `memory` 4,9 s · `documents` 13,1 s ·
+     * `codebase` 45,2 s. A `maxDocs` fölötti tár **kihagyva** (üres lista) — a mentés SOHA nem tehet egy
+     * olvasást másodperces műveletté. A darabszám `estimatedDocumentCount` (collection-metaadat, ~0 ms).
+     */
+    async loadByLiteralPhrase(input, regexSource, set) {
+        const registryEntry = embedding_1.FAM_StoreRegistry_Util.getEntry(input.table);
+        if (!registryEntry || !regexSource) {
+            return [];
+        }
+        const model = mongoose_1.default.models[registryEntry.dataParams.dataName];
+        if (!model) {
+            return [];
+        }
+        const size = await model.collection.estimatedDocumentCount();
+        if (size > set.maxDocs) {
+            return [];
+        }
+        const filter = this.buildFilter(input, registryEntry);
+        filter.content = { $regex: regexSource, $options: 'i' };
+        const rows = await model.collection
+            .find({ ...filter, _deleted: null }, { projection: { contentVector: 0 } })
+            .limit(set.limit)
+            .toArray();
+        return rows;
+    }
     /**
      * A topK-hit metaadat-betöltése `_id`-listából (az UNSCOPED read-fast-path-hez, SP-5.x perf). A főpool-
      * keresés UTÁN CSAK a tényleges hit-eket tölti (a hit-row + weight + recency összefűzéséhez), NEM mind a

package/build/src/_modules/retrieval/_services/fam-retrieval.control-service.js

@@ -1,6 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FAM_Retrieval_ControlService = exports.MAX_PAGE_SIZE = void 0;
+const fsm_dynamo_1 = require("@futdevpro/fsm-dynamo");
+const fam_cross_table_note_util_1 = require("../_collections/fam-cross-table-note.util");
 const fam_table_type_enum_1 = require("../../../_enums/fam-table.type-enum");
 const fam_reference_code_util_1 = require("../../../_collections/fam-reference-code.util");
 const config_control_service_1 = require("../../../_routes/server/config/config.control-service");
@@ -10,6 +12,7 @@ const fam_retrieval_candidate_data_service_1 = require("./fam-retrieval-candidat
 const fam_retrieval_suggestions_util_1 = require("./fam-retrieval-suggestions.util");
 const fam_memory_activation_util_1 = require("../_collections/fam-memory-activation.util");
 const fam_lexical_match_util_1 = require("../_collections/fam-lexical-match.util");
+const fam_literal_phrase_util_1 = require("../_collections/fam-literal-phrase.util");
 const fam_result_diversity_util_1 = require("../_collections/fam-result-diversity.util");
 const fam_memory_reactivation_control_service_1 = require("./fam-memory-reactivation.control-service");
 const fam_memory_cold_search_control_service_1 = require("./fam-memory-cold-search.control-service");
@@ -98,7 +101,12 @@ class FAM_Retrieval_ControlService {
         // FEAT-006 context-injection deduper: a hívó által MÁR injektált `_id`-k kizárása (a minScore/topK ELŐTT,
         // hogy ne foglaljanak helyet) — egy session ne kapja vissza ugyanazt a kontextust kétszer. A kizárás a
         // kód-exact-re IS vonatkozik (ha a session már birtokolja, nem kell újra, F3-1 ellenére sem).
-        const visibleHits = this.excludeSeen(mergedHits, query.excludeIds);
+        // ④c SZÓ SZERINTI IDÉZET-MENTÉS (2026-09-02): ha a query idézet-szerű, a pontosan egyező entry-k a
+        // vektor-úton KÍVÜL is bekerülnek. Mérve: a bemásolt hibaüzenet chunkja BE SEM KERÜLT a jelöltek
+        // közé (60/0), tehát ez recall-hiba — rangsorolással nem javítható. Ugyanaz a minta, mint a
+        // FEAT-003 kód-expanzió; a már bent lévő hitek NEM változnak, csak a hiányzók egészülnek ki.
+        const rescuedHits = await this.applyLiteralRescue({ query, config, scopeExpand, hits: mergedHits, includeContent });
+        const visibleHits = this.excludeSeen(rescuedHits, query.excludeIds);
         // ⑤ weight-szorzó MÁR a hit-eken (finalScore). ⑥ minScore-küszöb → relevantSet — DE F3-2: a kód-exact
         // citáció (`matchedCodes` nem-üres) BYPASS-olja a minScore-t (a determinisztikusan citált kód eleme
         // releváns a score-tól függetlenül; a `weight≤0` továbbra is kizárt, mert az már a merge ELŐTT kiesik).
@@ -112,11 +120,108 @@ class FAM_Retrieval_ControlService {
         const dedupedSet = FAM_Retrieval_ControlService.dedupeByContentHash(relevantSet);
         // ⑧ topK-vágás + dense-detektálás + suggestions.
         const result = this.buildResult({ query, relevantSet: dedupedSet, config, scopeExpand, detectedCodes });
+        // ⑨ KERESZT-TÁR „mellesleg"-javaslat (2026-09-01): a `hits` MÁR KÉSZ, és NEM változik tőle. Csak akkor
+        // fut, ha a hívó NEM kérte a `memory`/`knowledge` tárat (különben már benne lenne a listában).
+        const probeOutcome = await this.probeCrossTable({ query, queryVector, scopeExpand, config, result });
+        if (probeOutcome?.note) {
+            result.crossTableNote = probeOutcome.note;
+        }
+        if (query.includeCrossTableProbe && probeOutcome?.debug) {
+            result.crossTableProbe = probeOutcome.debug;
+        }
         // dsgn-013 §4 (MAM F2) — FELIDÉZÉS-megerősítés: a ténylegesen VISSZAADOTT `memory`-hitek „új energiát kapnak"
         // (lastRecalledAt=now, recallCount++, dormant=false). ASYNC fire-and-forget — NEM blokkolja a read választ.
-        this.reactivateReturnedMemoryHits(result.hits, config);
+        if (!query.skipReactivation) {
+            this.reactivateReturnedMemoryHits(result.hits, config);
+        }
         return result;
     }
+    /**
+     * A kereszt-tár szonda: EGY olcsó keresés a `memory` + `knowledge` táron, hogy kiderüljön, van-e ott
+     * ÉRDEMBEN erősebb találat. A döntés a tiszta `FAM_CrossTableNote_Util`-ban van (ott áll a kalibráció
+     * és a korlátok indoklása is); ez a metódus csak a jelölteket szerzi be.
+     *
+     * **Nem fut**, ha ki van kapcsolva, ha a küszöb 0, vagy ha a hívó ELEVE kérte ezeket a tárakat — akkor
+     * a találat már a listában van, és egy „mellesleg ott is van" mondat csak zaj lenne.
+     *
+     * **Hibatűrő:** a szonda MELLÉK-szolgáltatás. Ha bármi elromlik benne, a read válasza attól még teljes
+     * — némán elhagyjuk a jegyzetet, nem buktatjuk a hívást.
+     */
+    async probeCrossTable(set) {
+        // A DIAGNOSZTIKA kérése önmagában is ok a futásra: enélkül a kikapcsolt szonda mérhetetlen lenne.
+        if ((!set.config.crossTableNoteEnabled || !(set.config.crossTableNoteMinDelta > 0))
+            && !set.query.includeCrossTableProbe) {
+            return undefined;
+        }
+        const asked = new Set(set.query.tables);
+        const probeTables = set.config.crossTableNoteProbeTables
+            .filter((table) => !asked.has(table));
+        if (!probeTables.length) {
+            return undefined;
+        }
+        try {
+            // A tárak szondázása PÁRHUZAMOS. Mérve: sorosan +713 ms (+68,6%) minden read-en, ami egy
+            // 6,8%-os megszólalási arányhoz mérve elfogadhatatlan ár; a két keresés független egymástól.
+            const perTable = await Promise.all(probeTables.map((table) => this.probeTable(table, set)));
+            const candidates = perTable.flat();
+            // Az összevetés alapja a NYERS koszinusz — a `finalScore` tár-függő szorzókat hordoz (weight, decay,
+            // projekt-súly), így két tár között nem összemérhető.
+            const primaryTopScore = set.result.hits.reduce((top, hit) => (hit.score > top ? hit.score : top), 0);
+            // A JEGYZET csak akkor keletkezik, ha a funkció TÉNYLEGESEN be van kapcsolva. A diagnosztika
+            // (`includeCrossTableProbe`) megengedi a szonda LEFUTÁSÁT kikapcsolt állapotban is — de egy
+            // mérő-kapcsoló SOHA nem hozhat vissza egy kikapcsolt funkciót a válaszba.
+            const enabled = set.config.crossTableNoteEnabled && set.config.crossTableNoteMinDelta > 0;
+            const note = enabled ? fam_cross_table_note_util_1.FAM_CrossTableNote_Util.decide({
+                primaryTopScore: primaryTopScore,
+                candidates: candidates,
+                minDelta: set.config.crossTableNoteMinDelta,
+                minScore: set.config.crossTableNoteMinScore,
+            }) : undefined;
+            return { note: note, debug: fam_cross_table_note_util_1.FAM_CrossTableNote_Util.describeProbe(primaryTopScore, candidates, Boolean(note)) };
+        }
+        catch (error) {
+            fsm_dynamo_1.DyFM_Log.warn(`[read] a kereszt-tar szonda hibara futott, a jegyzet elmarad (a valasz teljes): ${String(error)}`);
+            return undefined;
+        }
+    }
+    /**
+     * EGY szonda-tár lekérdezése — a jelöltekké alakított találatokkal.
+     *
+     * A configot a SZONDÁZOTT tárra oldjuk fel, NEM az elsődlegesre. Ez nem finomhangolás: a `memory`
+     * rangsorát a saját decay-/superseded-/cold-search-beállításai alakítják, és ezek per-tár defaultokkal
+     * bírnak. Az elsődleges tár configjával szondázva MÁS jelölt-halmazt kapunk, mint amit ugyanaz a kérdés
+     * egy közvetlen `memory`-kereséssel adna — a mérés és a működés más eredményre jut, és a kalibráció
+     * olyan számra épülne, ami sehol nem érvényes. (Mérve: 5/44 vs 2/44 megszólalás ugyanazon a 44 eseten.)
+     */
+    async probeTable(table, set) {
+        const tableConfig = await this.resolveReadConfig(table, set.query);
+        // A szonda SAJÁT, kicsi topK-val fut — nem második találati listát épít, csak eldönti, van-e erősebb.
+        // A cold-search a KÖZVETLEN memória-kérdések dormant-mentőöve; egy mellék-jegyzet szondájának a
+        // forró pool elég — a superseded/dormant jelöltet úgyis kizárnánk. A szonda 3-as topK-jánál a
+        // `strongHotHits < topK` kapu szinte mindig nyitna, és a dormant-Mongo-munka a +514 ms része volt.
+        const probeConfig = {
+            ...tableConfig, topK: set.config.crossTableNoteTopK, minScore: 0,
+            memoryColdSearchEnabled: false,
+        };
+        const hits = await this.searchTable({
+            table: table, query: set.query, queryVector: set.queryVector,
+            scopeExpand: set.scopeExpand, config: probeConfig, includeContent: false,
+            // 4× fejtér a superseded/törmelék/`weight<=0` szűrésnek — 500 helyett 12 betöltött entry.
+            vectorTopK: Math.max(12, set.config.crossTableNoteTopK * 4),
+        });
+        return hits.slice(0, set.config.crossTableNoteTopK).map((hit) => {
+            // A `kind`/`tags`/`scope` NEM dekoráció: az MCP-n ÍRT memória-bejegyzésnek nincs fájl-útja
+            // (mérve: 21 jelöltből 16-nak), és ott a nyers ObjectId semmit nem mond a hívónak.
+            const leafScope = hit.scopePath?.[hit.scopePath.length - 1];
+            return {
+                id: hit.id, table: hit.table, score: hit.score,
+                sourceFilePath: hit.sourceFilePath, headingPath: hit.headingPath,
+                kind: hit.kind, tags: hit.tags,
+                scope: leafScope?.canonicalName,
+                superseded: hit.superseded,
+            };
+        });
+    }
     /**
      * A visszaadott top-K `memory`-hitek async felidézés-megerősítése (dsgn-013 §4). Fire-and-forget (void): a read
      * már elkészült, a felidézés-frissítés best-effort. Csak a `memory`-táras, `_id`-vel bíró hitre; üres → no-op.
@@ -189,6 +294,57 @@ class FAM_Retrieval_ControlService {
         }
         return Array.from(byId.values());
     }
+    /**
+     * SZÓ SZERINTI IDÉZET-MENTÉS. A `FAM_LiteralPhrase_Util` dönti el, hogy a query idézet-szerű-e (a
+     * kritériumok és a mért indoklás ott); ha igen, a pontosan egyező entry-ket a data-service hozza be a
+     * MÉRET-KAPU betartásával. A már meglévő hitek ÉRINTETLENEK — a mentés csak kiegészít.
+     *
+     * A mentett entry `score`-ja NEM 1,0 (az a kód-expanzió exact-citation szintje): egy szó szerinti
+     * mondat-egyezés erős, de nem azonos egy explicit azonosító-citációval. A `LITERAL_RESCUE_SCORE` a
+     * `relevanceFloor` fölé teszi őket, a rangsorban pedig a szokásos szorzók (weight, lexikai boost —
+     * beleértve az idézet-bónuszt) döntenek. Így a mentés **felszínre hoz**, de nem **tol félre**.
+     *
+     * Hibatűrő: a mentés MELLÉK-szolgáltatás — ha elszáll, a válasz a vektor-találatokkal teljes.
+     */
+    async applyLiteralRescue(set) {
+        if (!set.config.literalRescueEnabled) {
+            return set.hits;
+        }
+        const literal = fam_literal_phrase_util_1.FAM_LiteralPhrase_Util.extract(set.query.query);
+        if (!literal) {
+            return set.hits;
+        }
+        try {
+            const byId = new Map();
+            for (const hit of set.hits) {
+                byId.set(hit.id, hit);
+            }
+            const regexSource = fam_literal_phrase_util_1.FAM_LiteralPhrase_Util.toRegexSource(literal.phrase);
+            for (const table of Array.from(new Set(set.query.tables))) {
+                const entries = await new fam_retrieval_candidate_data_service_1.FAM_RetrievalCandidate_DataService().loadByLiteralPhrase({
+                    table: table,
+                    scopeIdSet: set.scopeExpand.scopeIdSet,
+                    tagFilter: set.query.tagFilter,
+                    kindFilter: set.query.kindFilter,
+                }, regexSource, { maxDocs: set.config.literalRescueMaxDocs, limit: set.config.literalRescueLimit });
+                for (const entry of entries) {
+                    const id = entry._id ? String(entry._id) : undefined;
+                    const weight = entry.weight ?? 1;
+                    // A `weight<=0` kizárás KONZISZTENS a vektor-ággal — a mentés nem kerülheti meg a tiltást.
+                    if (!id || weight <= 0 || byId.has(id)) {
+                        continue;
+                    }
+                    byId.set(id, this.toLiteralRescueHit({ entry, id, table, weight, includeContent: set.includeContent }));
+                }
+            }
+            return Array.from(byId.values());
+        }
+        catch (error) {
+            fsm_dynamo_1.DyFM_Log.warn(`[read] a szo szerinti idezet-mentes hibara futott, a valasz a vektor-talalatokkal `
+                + `teljes: ${String(error)}`);
+            return set.hits;
+        }
+    }
     /**
      * Egy kód-citáló entry beolvasztása a hit-halmazba (FEAT-003). `score=1.0` (exact citation = maximális
      * relevancia), `finalScore=1.0×weight` (a meglévő weight-modellbe illesztve). `weight≤0` → kizárt
@@ -221,6 +377,37 @@ class FAM_Retrieval_ControlService {
         set.byId.set(id, this.toCodeHit({ entry: set.entry, id, table: set.table, weight, matched, includeContent: set.includeContent }));
     }
     /** Egy kód-citáló entry → `FAM_RetrievalHit` (exact citation: `score=1.0`, `matchedCodes` kitöltve). */
+    /**
+     * A mentett entry `score`-ja. SZÁNDÉKOSAN a `relevanceFloor` (0,60) FÖLÖTT, de a kód-expanzió
+     * exact-citation 1,0-ja ALATT: a szó szerinti mondat-egyezés erős jel, de nem azonos egy explicit
+     * azonosító-citációval. Így a mentett elem biztosan látszik, de nem söpri le a valódi top-találatokat.
+     */
+    static LITERAL_RESCUE_SCORE = 0.75;
+    /** Egy szó szerint egyező entry → `FAM_RetrievalHit` (idézet-mentés; a `matchedCodes` üres marad). */
+    toLiteralRescueHit(set) {
+        const lastModified = set.entry.__lastModified;
+        const score = FAM_Retrieval_ControlService.LITERAL_RESCUE_SCORE;
+        return {
+            id: set.id,
+            table: set.table,
+            score: score,
+            weight: set.weight,
+            finalScore: score * set.weight,
+            content: set.includeContent ? set.entry.content : undefined,
+            contentHash: set.entry.contentHash,
+            kind: set.entry.kind,
+            tags: set.entry.tags ?? [],
+            ...this.ruleMeta(set.entry, set.table),
+            scopePath: (set.entry.scopePath ?? []),
+            source: set.entry.source,
+            sourceFilePath: set.entry.sourceFilePath ?? null,
+            absolutePath: set.entry.source?.absolutePath ?? null,
+            chunkType: set.entry.chunkType,
+            headingPath: set.entry.headingPath ?? [],
+            position: set.entry.position,
+            lastModifiedMs: lastModified ? new Date(lastModified).getTime() : 0,
+        };
+    }
     toCodeHit(set) {
         const lastModified = set.entry.__lastModified;
         return {
@@ -276,7 +463,7 @@ class FAM_Retrieval_ControlService {
             vectorHits = await embedding_1.FAM_VectorSearch_ControlService.getInstance().search({
                 table: set.table,
                 queryVector: set.queryVector,
-                topK: exports.MAX_PAGE_SIZE,
+                topK: set.vectorTopK ?? exports.MAX_PAGE_SIZE,
             });
             if (!vectorHits.length) {
                 return [];
@@ -312,12 +499,15 @@ class FAM_Retrieval_ControlService {
                 table: set.table,
                 queryVector: set.queryVector,
                 candidateIds: candidateIds,
-                topK: Math.min(candidateIds.length, exports.MAX_PAGE_SIZE),
+                topK: Math.min(candidateIds.length, set.vectorTopK ?? exports.MAX_PAGE_SIZE),
             });
         }
         // ⑤ weight-szorzó: finalScore = score × (weight ?? 1); weight ≤ 0 → kizárt (nem kerül a hits közé).
         // Improvement 2: a query lexikai term-jeit EGYSZER tokenizáljuk (a hibrid keyword-boost-hoz a toHit-ban).
         const queryTerms = fam_lexical_match_util_1.FAM_LexicalMatch_Util.tokenize(set.query.query);
+        // A szó szerinti idézet-egyezéshez a NYERS, sorrendhelyes token-sorozat kell (stopwordökkel együtt) —
+        // EGYSZER számoljuk ki a query-re, nem hit-enként.
+        const queryPhraseTokens = fam_lexical_match_util_1.FAM_LexicalMatch_Util.tokenizeSequence(set.query.query);
         const hits = [];
         for (const vectorHit of vectorHits) {
             const entry = byId.get(vectorHit.id);
@@ -330,6 +520,7 @@ class FAM_Retrieval_ControlService {
             }
             hits.push(this.toHit({
                 entry, vectorHit, table: set.table, weight, queryTerms: queryTerms,
+                queryPhraseTokens: queryPhraseTokens,
                 importChunkWeight: set.config.importChunkWeight, importSourceWeight: set.config.importSourceWeight,
                 includeContent: set.includeContent, config: set.config, nowMs: Date.now(),
             }));
@@ -363,6 +554,7 @@ class FAM_Retrieval_ControlService {
         });
         const seen = new Set(hits.map((hit) => hit.id));
         const queryTerms = fam_lexical_match_util_1.FAM_LexicalMatch_Util.tokenize(query.query);
+        const queryPhraseTokens = fam_lexical_match_util_1.FAM_LexicalMatch_Util.tokenizeSequence(query.query);
         for (const cold of coldHits) {
             const id = cold.entry._id;
             const weight = cold.entry.weight ?? 1;
@@ -371,6 +563,7 @@ class FAM_Retrieval_ControlService {
             }
             hits.push(this.toHit({
                 entry: cold.entry, vectorHit: { id: id, score: cold.score }, table: set.table, weight: weight, queryTerms: queryTerms,
+                queryPhraseTokens: queryPhraseTokens,
                 importChunkWeight: set.config.importChunkWeight, importSourceWeight: set.config.importSourceWeight,
                 includeContent: set.includeContent, config: set.config, nowMs: Date.now(),
             }));
@@ -466,7 +659,7 @@ class FAM_Retrieval_ControlService {
         const lexicalScore = set.config.keywordWeight > 0
             ? fam_lexical_match_util_1.FAM_LexicalMatch_Util.score(set.queryTerms, {
                 content: set.entry.content, headingPath: set.entry.headingPath, sourceFilePath: set.entry.source?.path,
-            })
+            }, set.queryPhraseTokens)
             : 0;
         const keywordBoost = 1 + set.config.keywordWeight * lexicalScore;
         // PROJEKT-SZINTU szorzo a `.famconfig.json`-bol — SZANDEKOSAN a temperalason KIVUL. A `weight` mezo az
@@ -727,6 +920,24 @@ class FAM_Retrieval_ControlService {
         const memoryFloorWeight = await this.resolveNumber(config, 'memory.floorWeight', ctx, 0.05);
         const memoryMaxFrequencyBoost = await this.resolveNumber(config, 'memory.maxFrequencyBoost', ctx, 2.5);
         const memoryActivationWeight = await this.resolveNumber(config, 'memory.activationWeight', ctx, 0.35);
+        // KERESZT-TÁR „mellesleg"-javaslat (2026-09-01) — a `hits`-hez SOHA nem nyúl, csak külön mezőt ad.
+        // SZO SZERINTI IDEZET-MENTES (2026-09-02) — recall-javitas, meret-kapuval.
+        const literalRescueValue = (await config.resolve('read.literalRescueEnabled', ctx)).value;
+        const literalRescueEnabled = literalRescueValue !== false;
+        const literalRescueMaxDocs = await this.resolveNumber(config, 'read.literalRescueMaxDocs', ctx, 10000);
+        const literalRescueLimit = await this.resolveNumber(config, 'read.literalRescueLimit', ctx, 10);
+        const crossTableNoteValue = (await config.resolve('read.crossTableNoteEnabled', ctx)).value;
+        const crossTableNoteEnabled = crossTableNoteValue !== false;
+        const crossTableNoteMinDelta = await this.resolveNumber(config, 'read.crossTableNoteMinDelta', ctx, 0.025);
+        const crossTableNoteMinScore = await this.resolveNumber(config, 'read.crossTableNoteMinScore', ctx, 0.45);
+        const crossTableNoteTopK = await this.resolveNumber(config, 'read.crossTableNoteTopK', ctx, 3);
+        const probeTablesRaw = (await config.resolve('read.crossTableNoteProbeTables', ctx)).value;
+        // Csak az ERVENYES szonda-tarak mennek at (memory/knowledge) — elgepelt config nem tud mas tarat szondazni.
+        const crossTableNoteProbeTables = String(typeof probeTablesRaw === 'string' ? probeTablesRaw : 'memory')
+            .split(',')
+            .map((item) => item.trim())
+            .filter((item) => item === fam_table_type_enum_1.FAM_Table.memory || item === fam_table_type_enum_1.FAM_Table.knowledge)
+            .map((item) => item);
         const memoryReactivateValue = (await config.resolve('memory.reactivateOnRead', ctx)).value;
         const memoryReactivateOnRead = memoryReactivateValue !== false;
         const memoryColdSearchValue = (await config.resolve('memory.coldSearchEnabled', ctx)).value;
@@ -736,6 +947,14 @@ class FAM_Retrieval_ControlService {
         return {
             topK: Math.min(topKDefault, exports.MAX_PAGE_SIZE),
             minScore: minScore,
+            literalRescueEnabled: literalRescueEnabled,
+            literalRescueMaxDocs: literalRescueMaxDocs,
+            literalRescueLimit: literalRescueLimit,
+            crossTableNoteEnabled: crossTableNoteEnabled,
+            crossTableNoteMinDelta: crossTableNoteMinDelta,
+            crossTableNoteMinScore: crossTableNoteMinScore,
+            crossTableNoteTopK: crossTableNoteTopK,
+            crossTableNoteProbeTables: crossTableNoteProbeTables.length ? crossTableNoteProbeTables : [fam_table_type_enum_1.FAM_Table.memory],
             relevanceFloor: relevanceFloor,
             importChunkWeight: importChunkWeight,
             importSourceWeight: importSourceWeight,

package/build/src/_modules/retrieval/index.js

@@ -10,11 +10,16 @@
  * opcionális relevance-filter = BACKLOG (NEM épül).
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.FAM_RetrievalSuggestions_Util = exports.FAM_RetrievalCandidate_DataService = exports.FAM_RuleScopeContext_Util = exports.FAM_RulePropagation_Util = exports.FAM_RuleInjection_Util = exports.FAM_RuleInjection_ControlService = exports.FAM_GlobalRule_ControlService = exports.MAX_PAGE_SIZE = exports.FAM_Retrieval_ControlService = void 0;
+exports.FAM_RetrievalSuggestions_Util = exports.FAM_RetrievalCandidate_DataService = exports.FAM_RuleScopeContext_Util = exports.FAM_RulePropagation_Util = exports.FAM_RuleInjection_Util = exports.FAM_RuleInjection_ControlService = exports.FAM_GlobalRule_ControlService = exports.FAM_MemoryRetention_Util = exports.FAM_MemoryRetention_ControlService = exports.MAX_PAGE_SIZE = exports.FAM_Retrieval_ControlService = void 0;
 // SP-5.1/5.2/5.3 — a read-pipeline orchestrátor
 var fam_retrieval_control_service_1 = require("./_services/fam-retrieval.control-service");
 Object.defineProperty(exports, "FAM_Retrieval_ControlService", { enumerable: true, get: function () { return fam_retrieval_control_service_1.FAM_Retrieval_ControlService; } });
 Object.defineProperty(exports, "MAX_PAGE_SIZE", { enumerable: true, get: function () { return fam_retrieval_control_service_1.MAX_PAGE_SIZE; } });
+// Memoria-retencio (2026-09-02): az alvo tormelek heti nyugdijazasa — a dontesi logika a pure utilban.
+var fam_memory_retention_control_service_1 = require("./_services/fam-memory-retention.control-service");
+Object.defineProperty(exports, "FAM_MemoryRetention_ControlService", { enumerable: true, get: function () { return fam_memory_retention_control_service_1.FAM_MemoryRetention_ControlService; } });
+var fam_memory_retention_util_1 = require("./_collections/fam-memory-retention.util");
+Object.defineProperty(exports, "FAM_MemoryRetention_Util", { enumerable: true, get: function () { return fam_memory_retention_util_1.FAM_MemoryRetention_Util; } });
 var fam_global_rule_control_service_1 = require("./_services/fam-global-rule.control-service");
 Object.defineProperty(exports, "FAM_GlobalRule_ControlService", { enumerable: true, get: function () { return fam_global_rule_control_service_1.FAM_GlobalRule_ControlService; } });
 // Rules-Management MP-2 — always-apply rule-injektálás (SessionStart inject + read-reflex) szerver-oldali assembly