@futdevpro/fdp-agent-memory 1.1.166 → 1.1.194

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

@@ -8,7 +8,7 @@
  * (BFR-AM-002/008); a bedrock-csere (MP-15) a `FAM_EmbeddingProvider` interfész mögött non-breaking.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.FAM_EmbeddingBootstrap_ControlService = exports.FAM_DupAuditScheduler_ControlService = exports.FAM_DupAudit_DataService = exports.FAM_DupAudit_ControlService = exports.FAM_DupFileRollup_Util = exports.FAM_DupForkPair_Util = exports.FAM_DupCoverage_ControlService = exports.FAM_ExactDuplication_ControlService = exports.FAM_DuplicateScan_ControlService = exports.FAM_EmbeddingCost_ControlService = exports.FAM_EmbeddingPipeline_ControlService = exports.FAM_EmbeddingPreset_ControlService = exports.FAM_StoreRegistry_Util = exports.FAM_STORE_REGISTRY = exports.FAM_DedupWarn_ControlService = exports.FAM_Entry_DataService = exports.FAM_HydrationCoordinator_ControlService = exports.FAM_VectorSearch_ControlService = exports.FAM_MOCK_EMBEDDING_DIMS = exports.FAM_Mock_EmbeddingProvider = exports.FAM_LMStudio_EmbeddingProvider = exports.FAM_OpenAI_EmbeddingProvider = exports.FAM_Embedding_ControlService = void 0;
+exports.FAM_EmbeddingBootstrap_ControlService = exports.FAM_DupAuditScheduler_ControlService = exports.FAM_DupAudit_DataService = exports.FAM_DupAudit_ControlService = exports.FAM_DupFileRollup_Util = exports.FAM_DupForkPair_Util = exports.FAM_DupCoverage_ControlService = exports.FAM_ExactDuplication_ControlService = exports.FAM_DuplicateScan_ControlService = exports.FAM_ExactDuplicatePrune_Util = exports.FAM_ExactDuplicatePrune_ControlService = exports.FAM_EmbeddingCost_ControlService = exports.FAM_EmbeddingPipeline_ControlService = exports.FAM_EmbeddingPreset_ControlService = exports.FAM_StoreRegistry_Util = exports.FAM_STORE_REGISTRY = exports.FAM_DedupWarn_ControlService = exports.FAM_Entry_DataService = exports.FAM_HydrationCoordinator_ControlService = exports.FAM_VectorSearch_ControlService = exports.FAM_MOCK_EMBEDDING_DIMS = exports.FAM_Mock_EmbeddingProvider = exports.FAM_LMStudio_EmbeddingProvider = exports.FAM_OpenAI_EmbeddingProvider = exports.FAM_Embedding_ControlService = void 0;
 // SP-2.1 — provider-dispatch kapu + providerek
 var fam_embedding_control_service_1 = require("./_services/fam-embedding.control-service");
 Object.defineProperty(exports, "FAM_Embedding_ControlService", { enumerable: true, get: function () { return fam_embedding_control_service_1.FAM_Embedding_ControlService; } });
@@ -39,6 +39,12 @@ var fam_embedding_pipeline_control_service_1 = require("./_services/fam-embeddin
 Object.defineProperty(exports, "FAM_EmbeddingPipeline_ControlService", { enumerable: true, get: function () { return fam_embedding_pipeline_control_service_1.FAM_EmbeddingPipeline_ControlService; } });
 var fam_embedding_cost_control_service_1 = require("./_services/fam-embedding-cost.control-service");
 Object.defineProperty(exports, "FAM_EmbeddingCost_ControlService", { enumerable: true, get: function () { return fam_embedding_cost_control_service_1.FAM_EmbeddingCost_ControlService; } });
+// BÁJTAZONOS ismétlés-NYESÉS (2026-09-01) — a szemantikus felderítővel ellentétben EZ töröl, de csak
+// bizonyítottan azonos tartalmat, és `dryRun` az alapértelmezés.
+var fam_exact_duplicate_prune_control_service_1 = require("./_services/fam-exact-duplicate-prune.control-service");
+Object.defineProperty(exports, "FAM_ExactDuplicatePrune_ControlService", { enumerable: true, get: function () { return fam_exact_duplicate_prune_control_service_1.FAM_ExactDuplicatePrune_ControlService; } });
+var fam_exact_duplicate_prune_util_1 = require("./_collections/fam-exact-duplicate-prune.util");
+Object.defineProperty(exports, "FAM_ExactDuplicatePrune_Util", { enumerable: true, get: function () { return fam_exact_duplicate_prune_util_1.FAM_ExactDuplicatePrune_Util; } });
 // near-duplikátum FELDERÍTŐ (read-only; user-direktíva 2026-06-21)
 var fam_duplicate_scan_control_service_1 = require("./_services/fam-duplicate-scan.control-service");
 Object.defineProperty(exports, "FAM_DuplicateScan_ControlService", { enumerable: true, get: function () { return fam_duplicate_scan_control_service_1.FAM_DuplicateScan_ControlService; } });

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

@@ -415,6 +415,10 @@ class FAM_Ingest_ControlService {
                         // A default display-relatív út a friss scan-gyökérhez igazodjon (FAM-REV-050) —
                         // egy korábban más root-reprezentációval (pl. scan-file basename) ingestelt chunk konzisztenssé.
                         await set.dataService.backfillSourceFilePath(item.existingId, set.file.relativePath);
+                        // SCOPE-backfill (2026-09-01): a scope-vak fallback MÁS scope alatt álló chunkot is
+                        // adoptál — enélkül az adoptált chunk a RÉGI projekt-név alatt ragadna, és a
+                        // scope-szűrt keresés az ÚJ néven nem találná meg (egy hibát cserélnénk másikra).
+                        await set.dataService.backfillScopePath(item.existingId, set.scopePath);
                         if (item.chunk) {
                             await set.dataService.backfillReferenceCodes(item.existingId, fam_reference_code_util_1.FAM_ReferenceCode_Util.extract(item.chunk.content));
                             // Pozíció-backfill (FAM-REV-061): a chunker pozíció-fix a régi equal-chunkokra is,
@@ -743,7 +747,23 @@ class FAM_Ingest_ControlService {
             const leaf = scopePath[scopePath.length - 1];
             filter['scopePath.scopeId'] = leaf.scopeId;
         }
-        return dataService.findHydratableList(filter);
+        const scoped = await dataService.findHydratableList(filter);
+        if (scoped.length || !scopePath.length) {
+            return scoped;
+        }
+        // SCOPE-VAK FALLBACK (2026-09-01, mert gyoker-ok). A fajl IDENTITASA az abszolut utvonal — a scope csak
+        // besorolas. Ha ugyanaz a mappa MAS projekt-nev alatt kerul ujra-szkennelesre (atnevezes utan a heti
+        // re-scan cel-unioja MINDKET nevet megorzi, es ugyanazt a mappat KETSZER szkenneli), akkor a scope-ra
+        // szurt lekerdezes URESET ad -> minden chunk `new`-nak latszik -> TELJES DUPLIKALAS, minden heten.
+        //
+        // MERVE: 51 578 dupla-csoport, mind KULONBOZO scopeId alatt; a legfrissebb eset 2026-08-31 09:32, amikor
+        // a `fdp-e2e-full/package.json` egyetlen scan-futasban ketszer kerult be (`futdevpro-e2e` 08:39 es
+        // `fdp-e2e-full` 09:32). Osszesen ~59 000 folosleges chunk.
+        //
+        // Ezert: ha a scope-olt talalat URES, meg egyszer keresunk KIZAROLAG az utvonalra. Ami igy elokerul, az
+        // UGYANANNAK a fajlnak a korabbi feldolgozasa — a delta-compare igy `equal`/`modified`-nak latja
+        // (adoptalja), nem duplikal. Ha a scope tenyleg valtozott, a `backfill`/update agak vezetik at.
+        return dataService.findHydratableList({ 'source.absolutePath': absolutePath });
     }
     /**
      * Törölt-fájl reconciliation (whole-file orphan, dsgn-004 §4.3 kiterjesztés). A scan-folder/scan-project

package/build/src/_modules/ingest/_services/fam-scan-job.control-service.js

@@ -480,6 +480,59 @@ class FAM_ScanJob_ControlService {
      * útvonalak a HÍVÓ `sourceLocation`-jéhez oldódnak fel (a szerver cwd-je eltér a CLI-étől — user-FR 2026-06-22):
      * a `configPath`/`root` ÉS a végső per-projekt `path` is.
      */
+    /**
+     * UTVONAL-SZERINTI DEDUP a cel-listan (2026-09-01, mert gyoker-ok). Ha UGYANAZ a mappa TOBB projekt-nev alatt
+     * szerepel, a scan ugyanazt a fajlt tobbszor olvassa be — es mivel a delta-osszevetes scope-ra szurt, a ket
+     * menet VAK egymasra, igy TELJES DUPLIKALAS keletkezik.
+     *
+     * MERVE: az utolso heti scan (2026-08-31) a `fdp-e2e-full/package.json`-t KETSZER vitte be, ket nev alatt
+     * (`futdevpro-e2e` 08:39 es `fdp-e2e-full` 09:32). Flotta-szinten 51 578 dupla-csoport, MIND kulonbozo
+     * scopeId alatt, osszesen ~59 000 folosleges chunk. Az ok: a heti re-scan a KORABBAN szkennelt celok
+     * UNIOJAT hasznalja, igy egy projekt-atnevezes utan a REGI es az UJ nev is bent marad — orokre.
+     *
+     * Az ELSO elofordulas nyer (a hivo altal megadott sorrend/az ujabb felderites elol all). A kihagyast
+     * LOGOLJUK — nema szures nem lehet (`core-rule-integrity` szelleme: ami kimarad, az latszodjon).
+     */
+    /** A projekt-név megegyezik-e a mappa nevével (a dedup döntőbírója — a lemez az igazság). */
+    static matchesFolderName(spec) {
+        const folder = String(spec.path ?? '')
+            .replace(/[\\/]+/g, '/')
+            .replace(/\/+$/, '')
+            .split('/')
+            .pop() ?? '';
+        return folder.length > 0 && folder.toLowerCase() === String(spec.project ?? '').toLowerCase();
+    }
+    static dedupeByPath(specs) {
+        const seen = new Map();
+        const dropped = [];
+        for (const spec of specs) {
+            // Az elvalasztot NORMALIZALJUK (a `\\` es a `/` ugyanaz a mappa Windowson), a zaro elvalasztot
+            // levagjuk, es kisbetusitunk — kulonben ugyanaz a cel ket irasmodban ketszer futna le.
+            const key = String(spec.path ?? '')
+                .replace(/[\\/]+/g, '/')
+                .replace(/\/+$/, '')
+                .toLowerCase();
+            const kept = seen.get(key);
+            if (kept) {
+                // DÖNTŐBÍRÓ: az a projekt-név nyer, ami a MAPPA NEVÉVEL egyezik. Átnevezés után a heti
+                // re-scan cél-uniója a RÉGI nevet is viszi, és az jellemzően előrébb áll — „első nyer"
+                // alapon a leváltott név maradna örökre. A mappa neve viszont a lemezen álló IGAZSÁG.
+                const winner = FAM_ScanJob_ControlService.matchesFolderName(spec)
+                    && !FAM_ScanJob_ControlService.matchesFolderName(kept) ? spec : kept;
+                const loser = winner === spec ? kept : spec;
+                dropped.push({ project: loser.project, keptAs: winner.project, path: spec.path });
+                seen.set(key, winner);
+                continue;
+            }
+            seen.set(key, spec);
+        }
+        if (dropped.length) {
+            fsm_dynamo_1.DyFM_Log.warn(`[scanJob] UTVONAL-DEDUP: ${dropped.length} cel kihagyva, mert ugyanarra a mappara mutat, `
+                + `mint egy masik projekt-nev (ez okozta a heti dupla-beolvasast): `
+                + dropped.map((d) => `${d.project} -> ${d.keptAs}`).join(', '));
+        }
+        return [...seen.values()];
+    }
     static resolveSpecs(input) {
         const base = (target) => (target && input.sourceLocation && !(0, path_1.isAbsolute)(target)) ? (0, path_1.resolve)(input.sourceLocation, target) : target;
         let specs = [];
@@ -497,7 +550,8 @@ class FAM_ScanJob_ControlService {
             specs = [...specs, ...input.extraTargets];
         }
         // A per-projekt `path` relatív → a sourceLocation-höz feloldva (a discover már abszolútat ad; a config relatív lehet).
-        return specs.map((spec) => ({ ...spec, path: base(spec.path) ?? spec.path }));
+        const resolved = specs.map((spec) => ({ ...spec, path: base(spec.path) ?? spec.path }));
+        return FAM_ScanJob_ControlService.dedupeByPath(resolved);
     }
     /** Egy szám-config feloldása (a hiba/hiány a fallback-ra esik — a cooldown sosem buktatja a job-ot). */
     static async resolveConfigNumber(key, fallback) {

package/build/src/_modules/ingest/_services/fam-scan-scheduler.control-service.js

@@ -4,6 +4,7 @@ exports.FAM_ScanScheduler_ControlService = void 0;
 const fsm_dynamo_1 = require("@futdevpro/fsm-dynamo");
 const fam_config_level_type_enum_1 = require("../../../_enums/fam-config-level.type-enum");
 const config_control_service_1 = require("../../../_routes/server/config/config.control-service");
+const retrieval_1 = require("../../retrieval");
 const fam_scan_job_control_service_1 = require("./fam-scan-job.control-service");
 const fam_scan_job_data_service_1 = require("./fam-scan-job.data-service");
 const embedding_1 = require("../../embedding");
@@ -120,6 +121,10 @@ class FAM_ScanScheduler_ControlService {
                 + `(slot: ${FAM_ScanScheduler_ControlService.DAY_NAMES[day] ?? day} ${hour}:00). Indítás…`);
             await this.markRan(config, nowMs);
             await this.triggerRescan();
+            // RETENCIÓ (2026-09-02): a heti ütemben az alvó törmelék nyugdíjazása is fut — a lényege az
+            // automatizmus (különben a törmelék sosem vonul nyugdíjba). A scan-tól FÜGGETLEN munka, nem
+            // várja meg (a scan async, waitMs:0); best-effort: a hibája nem buktatja a ticket.
+            await this.runWeeklyRetention();
         }
         catch (error) {
             fsm_dynamo_1.DyFM_Log.warn(`[FAM scanScheduler] heti re-scan tick sikertelen (best-effort): ${error?.message}`);
@@ -128,6 +133,27 @@ class FAM_ScanScheduler_ControlService {
             this.ticking = false;
         }
     }
+    /**
+     * A heti retenció: az alvó törmelék (`user_prompt`/`temporary_context`, sosem felidézett, 30+ napos)
+     * nyugdíjazása. Kapu: `memory.retireTemporaryEnabled` (default true). A szabály + indoklás:
+     * `retrieval/_collections/fam-memory-retention.util.ts`. Best-effort — a hiba WARN, nem tick-bukás.
+     */
+    async runWeeklyRetention() {
+        try {
+            const retention = retrieval_1.FAM_MemoryRetention_ControlService.getInstance();
+            if (!(await retention.isAutoEnabled())) {
+                fsm_dynamo_1.DyFM_Log.log('[FAM scanScheduler] heti retenció KIKAPCSOLVA (`memory.retireTemporaryEnabled=false`) — kihagyva.');
+                return;
+            }
+            const report = await retention.retire({ dryRun: false });
+            fsm_dynamo_1.DyFM_Log.log(`[FAM scanScheduler] heti retenció kész: ${report.retired} nyugdíjazva `
+                + `(${report.scanned} jelöltből; ${report.keptTooYoung} még fiatal, `
+                + `${report.alreadySuperseded} már nyugdíjas).`);
+        }
+        catch (error) {
+            fsm_dynamo_1.DyFM_Log.warn(`[FAM scanScheduler] heti retenció sikertelen (best-effort): ${error?.message}`);
+        }
+    }
     /** A TELJES re-scan indítása: `scan.weeklyRescanRoot` (ha van) VAGY a legutóbbi durable scan-job cél-specjei. */
     async triggerRescan() {
         const origin = { agent: 'fam-scheduler', label: 'weekly-rescan' };

package/build/src/_modules/mcp/_collections/fam-core-tools.const.js

@@ -66,6 +66,17 @@ const READ_INPUT_SCHEMA = {
                         description: 'Feltárás-mélység: `deep` → mély feltárás (sokkal több chunk; a `read.deepTopK` '
                             + 'az alap topK helyett). Default `normal`. Az explicit `topK` mindig felülír.',
                     },
+                    skipReactivation: {
+                        type: 'boolean',
+                        description: 'DIAGNOSZTIKA: a visszaadott memory-hitek NE kapjanak felidézés-megerősítést '
+                            + '(recallCount++). Mérő-/kalibrációs forgalomhoz — a mérés nem terhelheti a mért rendszert.',
+                    },
+                    includeCrossTableProbe: {
+                        type: 'boolean',
+                        description: 'DIAGNOSZTIKA (nem termék-funkció): a kereszt-tár szonda nyers döntési adata '
+                            + '(`crossTableProbe`) akkor is kerüljön a válaszba, ha a küszöb alatt maradt — a '
+                            + 'küszöb-kalibráció csak így mérhető a rendszer VALÓS viselkedésén. A `hits`-hez nem nyúl.',
+                    },
                 },
                 required: ['tables', 'query'],
                 additionalProperties: false,

package/build/src/_modules/mcp/_services/fam-read-tool.service.js

@@ -319,6 +319,8 @@ class FAM_ReadTool_Service {
             kindFilter: query.kindFilter,
             excludeIds: query.excludeIds,
             depth: query.depth,
+            includeCrossTableProbe: query.includeCrossTableProbe,
+            skipReactivation: query.skipReactivation,
             // Per-query tartalom-kapcsolo atvezetese (2026-08-14 lelet: eddig itt VESZETT EL).
             includeContent: query.includeContent,
         };

package/build/src/_modules/mcp/_services/fam-write-tool.service.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FAM_WriteTool_Service = void 0;
 const fsm_dynamo_1 = require("@futdevpro/fsm-dynamo");
+const fam_table_type_enum_1 = require("../../../_enums/fam-table.type-enum");
 const error_codes_const_1 = require("../../../_collections/error-codes.const");
 const fam_error_factory_util_1 = require("../../../_collections/fam-error-factory.util");
 const fam_entry_data_model_1 = require("../../../_models/data-models/fam-entry.data-model");
@@ -333,19 +334,40 @@ class FAM_WriteTool_Service {
         // FAM-REV-051 bulk: `sourceFilePath`/`absolutePath` → egy fájl ÖSSZES chunkja; `id`/`query` → egyetlen.
         const targets = await this.resolveDeleteTargets(input, dataService, 'write-delete');
         const deletedIds = [];
+        // RETIRE-NOT-DELETE a `memory` táron (2026-09-02, owner-elv: „nem baj, ha fennmarad olyan memória,
+        // amit a Claude már elfelejtett — sőt!"). A memória-törlés NYUGDÍJAZÁS: `superseded + retiredAt`,
+        // a tartalom és a vektor marad (a penalty süllyeszti, a cold-search megtalálja). Más táron a
+        // viselkedés VÁLTOZATLAN — ott a fájl az igazság, a scan a törölt chunkot úgyis újra behozná.
+        // Valódi hard-delete-re a scope-maintenance reset az admin-út.
+        const retireInsteadOfDelete = input.table === fam_table_type_enum_1.FAM_Table.memory;
+        const now = Date.now();
         for (const entry of targets) {
             if (!entry._id) {
                 continue;
             }
-            // absolute=false → soft-delete (Dynamo-konvenció: `_deleted` marker, archív collection).
-            await dataService.deleteData(entry._id, false);
-            // Pool-coherence (FAM-REV-046): a törölt vektort a hívó-process in-memory LVS-pool-jából is kivesszük.
-            embedding_1.FAM_VectorSearch_ControlService.getInstance().removeVector(input.table, entry._id);
+            if (retireInsteadOfDelete) {
+                await dataService.updateData({
+                    filterBy: { _id: entry._id },
+                    update: { $set: { superseded: true, retiredAt: now } },
+                });
+                // A vektor a poolban MARAD — a superseded-szemantika része (a rangsor-büntetés süllyeszti).
+            }
+            else {
+                // absolute=false → soft-delete (Dynamo-konvenció: `_deleted` marker, archív collection).
+                await dataService.deleteData(entry._id, false);
+                // Pool-coherence (FAM-REV-046): a törölt vektort a hívó-process in-memory LVS-pool-jából is kivesszük.
+                embedding_1.FAM_VectorSearch_ControlService.getInstance().removeVector(input.table, entry._id);
+            }
             deletedIds.push(entry._id);
         }
-        const warnings = deletedIds.length > 1
-            ? [`Bulk file-delete: ${deletedIds.length} chunk soft-delete-elve (cél: ${input.target?.by}='${input.target?.value}').`]
-            : [];
+        const warnings = [];
+        if (retireInsteadOfDelete && deletedIds.length) {
+            warnings.push(`A memory táron a törlés NYUGDÍJAZÁS: ${deletedIds.length} bejegyzés superseded+retiredAt `
+                + 'jelölést kapott — hidegen kereshető marad, nem törlődött (owner-elv: a felejtett memória is érték).');
+        }
+        else if (deletedIds.length > 1) {
+            warnings.push(`Bulk file-delete: ${deletedIds.length} chunk soft-delete-elve (cél: ${input.target?.by}='${input.target?.value}').`);
+        }
         return this.baseOutput({
             operation: input.operation, table: input.table,
             scopePath: (targets[0]?.scopePath ?? []),

package/build/src/_modules/retrieval/_collections/fam-cross-table-note.util.js

@@ -0,0 +1,136 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FAM_CrossTableNote_Util = void 0;
+const fam_memory_retention_util_1 = require("./fam-memory-retention.util");
+/**
+ * NEM-TUDÁS jelöltek: nyers beszélgetés-törmelék, amivel SOHA nem szabad „mellesleg"-et adni.
+ *
+ * **Mért indok (2026-09-01):** az aktív `memory` tár **20,2%-a (8 717 bejegyzés) `kind: user_prompt` /
+ * `tags: [temporary_context]`** — szó szerinti user-input, amit a session tárolt el kontextusnak. Ezek
+ * rövidek és tematikusak, ezért a nyers koszinuszuk MAGASRA fut, és a 44 esetes benchmarkban a 12
+ * legerősebb jelöltből **10 ilyen volt**. Egy nyers prompt-idézet nem válasz a „láttuk már ezt?"
+ * kérdésre — a javaslat tőle nem hasznos, hanem félrevezető.
+ *
+ * Ugyanezen az alapon esik ki a **`fs-summary` / `scan-summary`** is: az egy mappa-listázás gépi
+ * összefoglalója. A benchmarkban pont a döntési zónában ült (+0,022), és semmilyen kérdésre nem válasz.
+ * (A scan-summary zaja külön is mért, ismert probléma — `reference_fam_scan_summary_weight_cap`.)
+ */
+// A MEMORIA-tormelek definicioja a KOZOS utilbol jon (fam-memory-retention.util) — egy definicio,
+// harom felhasznalas (retencio + reaktivacio-szuro + kereszt-tar szonda). Itt CSAK a knowledge-tar
+// sajat zaja (fs-summary/scan-summary) egeszul ki.
+const NON_KNOWLEDGE_KINDS = ['fs-summary'];
+const NON_KNOWLEDGE_TAGS = ['scan-summary'];
+class FAM_CrossTableNote_Util {
+    /**
+     * A döntés. `undefined` = **csend**: nincs mező a válaszban. Szándékosan NEM adunk „nem találtam
+     * erősebbet" üzenetet — az minden válaszra ráterhelne egy sort azért, hogy semmit ne közöljön.
+     */
+    static decide(input) {
+        const usable = input.candidates.filter((candidate) => candidate.superseded !== true
+            && !FAM_CrossTableNote_Util.isNonKnowledge(candidate)
+            && Number.isFinite(candidate.score)
+            && candidate.score >= input.minScore);
+        if (!usable.length || !(input.minDelta > 0)) {
+            return undefined;
+        }
+        // LEGFELJEBB EGY tétel: a mérés szerint úgyis 0-1 van, és egy 3-elemű mellék-lista már hígítás
+        // — pontosan az a zaj, ami miatt nem a `hits`-be tesszük.
+        const best = [...usable].sort((a, b) => b.score - a.score)[0];
+        const delta = best.score - input.primaryTopScore;
+        if (delta < input.minDelta) {
+            return undefined;
+        }
+        const heading = best.headingPath?.length ? best.headingPath.join(' › ') : undefined;
+        return {
+            table: best.table,
+            delta: Number(delta.toFixed(4)),
+            hit: {
+                id: best.id,
+                table: best.table,
+                score: best.score,
+                sourceFilePath: best.sourceFilePath,
+                heading: heading,
+                label: FAM_CrossTableNote_Util.label(best),
+            },
+            message: FAM_CrossTableNote_Util.message({
+                table: best.table,
+                candidateScore: best.score,
+                primaryTopScore: input.primaryTopScore,
+                location: FAM_CrossTableNote_Util.label(best),
+            }),
+        };
+    }
+    /** Beszélgetés-törmelék / gépi zaj-e a jelölt. A memória-törmelék részt a közös util dönti el. */
+    static isNonKnowledge(candidate) {
+        if (fam_memory_retention_util_1.FAM_MemoryRetention_Util.isDebris({ kind: candidate.kind, tags: candidate.tags })) {
+            return true;
+        }
+        if (candidate.kind && NON_KNOWLEDGE_KINDS.includes(candidate.kind)) {
+            return true;
+        }
+        return (candidate.tags ?? []).some((tag) => NON_KNOWLEDGE_TAGS.includes(tag));
+    }
+    /**
+     * A jelölt AZONOSÍTHATÓ megnevezése. A fájl-út a legjobb, de az MCP-n ÍRT memória-bejegyzésnek nincs
+     * (mérve: a 21 szonda-jelöltből 16-nak). Ott a nyers ObjectId semmit nem mond a hívónak — a `kind` +
+     * `tags` + `scope` viszont pontosan megmondja, MIRŐL szól a jegyzet, és hogy érdemes-e megnyitni.
+     */
+    static label(candidate) {
+        if (candidate.sourceFilePath) {
+            return candidate.sourceFilePath;
+        }
+        if (candidate.headingPath?.length) {
+            return candidate.headingPath.join(' › ');
+        }
+        const parts = [];
+        if (candidate.kind) {
+            parts.push(candidate.kind);
+        }
+        if (candidate.tags?.length) {
+            parts.push(`[${candidate.tags.slice(0, 4).join(', ')}]`);
+        }
+        if (candidate.scope) {
+            parts.push(`(${candidate.scope})`);
+        }
+        // Az `id` MINDIG ott van a `hit.id`-ben — a szövegbe csak akkor kerül, ha tényleg nincs jobb.
+        return parts.length ? `${parts.join(' ')} — id: ${candidate.id}` : `id: ${candidate.id}`;
+    }
+    /**
+     * A szonda nyers döntési adata (diagnosztika). A `superseded` jelölt SZÁNDÉKOSAN benne marad a
+     * legjobb-választásban itt — a mérésnek látnia kell, ha a szonda amúgy egy leváltott generációt
+     * hozott volna; a `decide` ettől függetlenül kizárja.
+     */
+    static describeProbe(primaryTopScore, candidates, fired) {
+        // A diagnosztika a KÜSZÖB-független képet adja, de a TARTALMI kizárásokat (leváltott generáció,
+        // beszélgetés-törmelék) ALKALMAZZA — különben a kalibráció olyan jelöltre számolna deltát, amit a
+        // rendszer sosem ajánlana, és megint nem azt mérnénk, ami ténylegesen történik.
+        const eligible = candidates.filter((candidate) => candidate.superseded !== true
+            && !FAM_CrossTableNote_Util.isNonKnowledge(candidate)
+            && Number.isFinite(candidate.score));
+        const best = [...eligible]
+            .sort((a, b) => b.score - a.score)[0];
+        return {
+            primaryTopScore: primaryTopScore,
+            candidateCount: candidates.length,
+            eligibleCount: eligible.length,
+            best: best ? {
+                table: best.table,
+                score: best.score,
+                delta: Number((best.score - primaryTopScore).toFixed(4)),
+                label: FAM_CrossTableNote_Util.label(best),
+                superseded: best.superseded,
+            } : undefined,
+            fired: fired,
+        };
+    }
+    /** Az ember-olvasható mondat. Megmondja, MI van ott és MIÉRT szólunk — a hívó dönt, mi lesz vele. */
+    static message(set) {
+        const comparison = set.primaryTopScore > 0
+            ? `${set.candidateScore.toFixed(3)} vs ${set.primaryTopScore.toFixed(3)}`
+            : `${set.candidateScore.toFixed(3)}, miközben a kért tárban nem volt érdemi találat`;
+        return `Mellesleg: a(z) \`${set.table}\` tárban ÉRDEMBEN erősebb találat van erre (${comparison}) — `
+            + `${set.location}. A fenti listát ez NEM módosította; ha a kérdés inkább „láttuk-e már ezt", `
+            + 'érdemes lehet oda is belenézni.';
+    }
+}
+exports.FAM_CrossTableNote_Util = FAM_CrossTableNote_Util;

package/build/src/_modules/retrieval/_collections/fam-lexical-match.util.js

@@ -31,6 +31,25 @@ class FAM_LexicalMatch_Util {
     ];
     /** A tő MINIMÁLIS hossza tövezés után (a túl-tövezés hamis egyezéseket hozna). */
     static MIN_STEM_LEN = 4;
+    /**
+     * SZÓ SZERINTI IDÉZET-EGYEZÉS (2026-09-02, black-box futás lelete). A term-átfedés egy HALMAZ-arány:
+     * nem tudja megkülönböztetni a „ugyanazok a szavak szétszórva" esetet a „pontosan ez a mondat van benne"
+     * esettől — pedig az utóbbi nagyságrenddel erősebb relevancia-jel.
+     *
+     * **Mért eset:** a `402 Payment Required - You must sign up for private packages` hibaüzenet szó szerinti
+     * bemásolása (a legtermészetesebb fejlesztői reflex) a `fdp-never-public-packages` szabályt a **#7**
+     * helyre tette 60 találatból — holott a szabály-fájl **literálisan tartalmazza ezt a mondatot**, és övé
+     * volt a mezőny LEGMAGASABB term-átfedése (0,325). A nyers koszinusza viszont csak 0,480 volt (egy
+     * kontextus nélküli hibaüzenet gyenge szemantikus jel), és a ×1,195-ös boost nem hozta fel.
+     *
+     * A phrase-bónusz ezt a hibaosztályt fedi — bemásolt hibaüzenet, idézett mondat, pontos azonosító —, és
+     * a PARAFRAZEÁLT kérdéseket NEM érinti: ott nincs hosszú, szó szerinti egyezés, tehát nincs bónusz sem.
+     */
+    static MIN_PHRASE_LEN = 3;
+    /** A phrase-bónusz maximuma (a teljes query-hossznyi szó szerinti egyezésre jár). */
+    static PHRASE_BONUS = 0.6;
+    /** A vizsgált query-tokenek plafonja — egy hosszú prompt ne csináljon O(n²) munkát hit-enként. */
+    static MAX_PHRASE_TOKENS = 24;
     /** Tokenizálás: kisbetűsít, nem-alfanumerikuson tör, stopword + rövid token kihagyva, DEDUP (Set). */
     static tokenize(text) {
         const terms = new Set();
@@ -62,12 +81,53 @@ class FAM_LexicalMatch_Util {
         }
         return undefined;
     }
+    /**
+     * NYERS, SORRENDHELYES token-sorozat (a phrase-egyezéshez). A `tokenize`-zal ellentétben **NEM** szűr
+     * stopwordöt és **NEM** dedupál: a szó szerinti idézetben a kötőszavak is a mondat részei — pont azok
+     * teszik idézetté. A rövid tokenek (`MIN_TOKEN_LEN` alatt) itt is kimaradnak, mert a normalizált
+     * szövegben sem szerepelnek.
+     */
+    static tokenizeSequence(text) {
+        if (!text) {
+            return [];
+        }
+        return text.toLowerCase()
+            .split(/[^a-z0-9áéíóöőúüű]+/)
+            .filter((token) => token.length >= FAM_LexicalMatch_Util.MIN_TOKEN_LEN);
+    }
+    /** Az entry kereshető szövegének normalizált alakja (kisbetűs, egy-szóközös) — a phrase-kereséshez. */
+    static normalizeForPhrase(text) {
+        if (!text) {
+            return '';
+        }
+        return ` ${text.toLowerCase().split(/[^a-z0-9áéíóöőúüű]+/).filter(Boolean).join(' ')} `;
+    }
+    /**
+     * A leghosszabb SZÓ SZERINTI, összefüggő query-részlet hossza, ami az entry szövegében is megvan
+     * (0, ha nincs `MIN_PHRASE_LEN`-nél hosszabb egyezés). A leghosszabb ablaktól indul és az ELSŐ
+     * egyezésnél visszatér — így a tipikus „nincs idézet" eset is korlátos munkával zárul.
+     */
+    static longestPhraseRun(queryTokens, normalizedEntryText) {
+        const tokens = queryTokens.slice(0, FAM_LexicalMatch_Util.MAX_PHRASE_TOKENS);
+        if (tokens.length < FAM_LexicalMatch_Util.MIN_PHRASE_LEN || !normalizedEntryText) {
+            return 0;
+        }
+        for (let length = tokens.length; length >= FAM_LexicalMatch_Util.MIN_PHRASE_LEN; length--) {
+            for (let start = 0; start + length <= tokens.length; start++) {
+                const phrase = ` ${tokens.slice(start, start + length).join(' ')} `;
+                if (normalizedEntryText.includes(phrase)) {
+                    return length;
+                }
+            }
+        }
+        return 0;
+    }
     /**
      * Lexikai átfedés-score (0..1): a `queryTerms` hányad része van jelen az entry kereshető szövegében.
      * `content`-egyezés = base-átfedés; `headingPath`/`sourceFilePath`-egyezés = + `TITLE_PATH_BONUS` súly (1-re vágva).
      * Üres query-term-halmaz → 0 (nincs jel → nincs boost). PURE.
      */
-    static score(queryTerms, entry) {
+    static score(queryTerms, entry, queryPhraseTokens) {
         if (!queryTerms.size) {
             return 0;
         }
@@ -94,7 +154,20 @@ class FAM_LexicalMatch_Util {
         const total = queryTerms.size;
         const base = baseMatched / total;
         const titleBonus = (titleMatched / total) * FAM_LexicalMatch_Util.TITLE_PATH_BONUS;
-        return Math.min(1, base + titleBonus);
+        // SZÓ SZERINTI IDÉZET-BÓNUSZ: a query hány százaléka szerepel ÖSSZEFÜGGŐEN, szó szerint az entry
+        // szövegében. A halmaz-átfedés ezt nem látja (neki a szórt egyezés ugyanannyi) — pedig egy bemásolt
+        // hibaüzenet vagy idézett mondat majdnem biztos relevancia-jel. Az indoklás + a mért eset a
+        // `MIN_PHRASE_LEN` konstans doc-commentjében.
+        let phraseBonus = 0;
+        if (queryPhraseTokens && queryPhraseTokens.length) {
+            const searchable = FAM_LexicalMatch_Util.normalizeForPhrase(`${entry.content ?? ''} ${(entry.headingPath ?? []).join(' ')} ${entry.sourceFilePath ?? ''}`);
+            const run = FAM_LexicalMatch_Util.longestPhraseRun(queryPhraseTokens, searchable);
+            if (run > 0) {
+                const considered = Math.min(queryPhraseTokens.length, FAM_LexicalMatch_Util.MAX_PHRASE_TOKENS);
+                phraseBonus = FAM_LexicalMatch_Util.PHRASE_BONUS * (run / considered);
+            }
+        }
+        return Math.min(1, base + titleBonus + phraseBonus);
     }
 }
 exports.FAM_LexicalMatch_Util = FAM_LexicalMatch_Util;

package/build/src/_modules/retrieval/_collections/fam-literal-phrase.util.js

@@ -0,0 +1,74 @@
+"use strict";
+/**
+ * SZÓ SZERINTI IDÉZET-MENTÉS — a döntés, hogy egy query megéri-e a pontos szöveg-keresést (2026-09-02).
+ *
+ * **A mért hiba.** A black-box futás leletét külön ellenőrizve: a
+ * `402 Payment Required - You must sign up for private packages` hibaüzenet **szó szerinti bemásolása** —
+ * a legtermészetesebb fejlesztői reflex — a szabályt nem hozta be. Az első hipotézisem (rangsor-hiba) a
+ * mérésen **MEGBUKOTT**: a 60 visszaadott találatból **egy sem tartalmazta a „402"-t**, vagyis a mondatot
+ * hordozó chunk **be sem került a jelöltek közé**. Ez **recall-hiba**: egy kontextus nélküli hibaüzenet
+ * embeddingje távol esik a szabály-próza embeddingjétől, és amit a vektor-réteg nem hoz be, azt semmilyen
+ * rangsor-javítás nem érheti el.
+ *
+ * **A megoldás mintája MÁR LÉTEZIK:** a FEAT-003 kód-expanzió (`applyCodeExpansion`) pontosan ezt csinálja
+ * azonosító-kódokra — ha a query kódot tartalmaz, a citáló elemek determinisztikusan bekerülnek, a
+ * vektor-rangsortól függetlenül. Ez a util ugyanezt terjeszti ki a **szó szerinti idézetre**.
+ *
+ * **Miért kell szigorú kapu.** A mentés Mongo-oldali szöveg-keresés, ami a nagy tárakon collection-scan.
+ * Mérve (2026-09-02): `rules` 296 ms · `coding_patterns` 504 ms · `knowledge` 2,1 s · `memory` 4,9 s ·
+ * `documents` 13,1 s · `codebase` 45,2 s. Ezért a mentés (1) csak IDÉZET-SZERŰ query-re fut, és (2) csak
+ * a `read.literalRescueMaxDocs` alatti méretű tárakon.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FAM_LiteralPhrase_Util = void 0;
+/** A minimális token-szám: ennél rövidebb részlet nem idézet, hanem véletlen szó-egybeesés. */
+const MIN_TOKENS = 5;
+/** A maximális token-szám: a hosszú promptot levágjuk (a regex-költség és a találhatóság miatt is). */
+const MAX_TOKENS = 16;
+/**
+ * A „disztinktív" token minimális hossza. Egy csupa rövid, köznapi szóból álló mondat (`mi a teendo ha a
+ * build elszall`) nem idézet — az a normál szemantikus keresés dolga. Számjegyet tartalmazó token (hibakód,
+ * verzió, azonosító) MINDIG disztinktívnek számít.
+ */
+const DISTINCTIVE_LEN = 7;
+class FAM_LiteralPhrase_Util {
+    /**
+     * IDÉZET-SZERŰ-e a query, és ha igen, mit keressünk. `undefined` = nem éri meg a szöveg-keresés.
+     *
+     * **Ismert korlát, nyíltan:** a keresett szöveg a query ELEJÉTŐL vett, `MAX_TOKENS`-ig tartó összefüggő
+     * részlet — vagyis a TISZTÁN bemásolt idézetre működik. Ha a felhasználó saját mondatba ágyazza az
+     * idézetet („npm publish failed with 402 … what should I do"), a szó szerinti egyezés elmarad, és a
+     * mentés nem talál. Az a hibaosztály viszont **mérve nem is szorul mentésre**: ott a normál vektor-út
+     * behozza a szabályt (#2 helyezés). A mentés a lyukat foltozza, nem a működő utat írja át.
+     */
+    static extract(query) {
+        const tokens = String(query ?? '')
+            .toLowerCase()
+            .split(/[^a-z0-9áéíóöőúüű]+/)
+            .filter((token) => token.length >= 2);
+        if (tokens.length < MIN_TOKENS) {
+            return undefined;
+        }
+        const window = tokens.slice(0, MAX_TOKENS);
+        if (!window.some((token) => FAM_LiteralPhrase_Util.isDistinctive(token))) {
+            return undefined;
+        }
+        return { phrase: window.join(' '), tokenCount: window.length };
+    }
+    /** Disztinktív-e a token: számjegyet tartalmaz (hibakód/verzió/azonosító) VAGY elég hosszú. */
+    static isDistinctive(token) {
+        return /[0-9]/.test(token) || token.length >= DISTINCTIVE_LEN;
+    }
+    /**
+     * A szó szerinti kereséshez használt regex: a tokenek között TETSZŐLEGES nem-alfanumerikus elválasztó
+     * állhat, mert a korpuszban a mondat írásjelekkel, sortöréssel, backtickkel tagolt (`402 Payment
+     * Required — You must…`). A tokenek escape-elve — a query SOHA nem tud regexet injektálni.
+     */
+    static toRegexSource(phrase) {
+        return phrase
+            .split(' ')
+            .map((token) => token.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'))
+            .join('[^a-z0-9áéíóöőúüű]+');
+    }
+}
+exports.FAM_LiteralPhrase_Util = FAM_LiteralPhrase_Util;