@futdevpro/fdp-agent-memory 1.1.163 → 1.1.177

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,
@@ -484,6 +488,8 @@ class FAM_Ingest_ControlService {
             scopePath: set.scopePath,
             // Súly-kiemelés (FAM-REV-055): a scan-`weights`-ből feloldott fájl-súly (undefined → a tár model-default).
             weight: set.file.weight,
+            // A projekt-szintu szorzo a `.famconfig.json`-bol — a retrieval TEMPERALATLANUL alkalmazza.
+            projectWeight: set.file.projectWeight,
             sourceFilePath: set.file.relativePath,
             chunkIndex: set.chunk.chunkIndex,
             chunkTotal: set.chunk.chunkTotal,
@@ -741,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.control-service.js

@@ -8,6 +8,7 @@ const fsm_dynamo_1 = require("@futdevpro/fsm-dynamo");
 const config_catalog_const_1 = require("../../../_collections/config-catalog.const");
 const config_control_service_1 = require("../../../_routes/server/config/config.control-service");
 const fam_famignore_util_1 = require("../_collections/fam-famignore.util");
+const fam_project_config_util_1 = require("../_collections/fam-project-config.util");
 const fam_file_routing_util_1 = require("../_collections/fam-file-routing.util");
 const fam_glob_match_util_1 = require("../_collections/fam-glob-match.util");
 const fam_scan_path_util_1 = require("../_collections/fam-scan-path.util");
@@ -48,6 +49,17 @@ class FAM_Scan_ControlService {
         // (in-repo, gitignore-szerű; folder/project scan-nél — a scan-file egyetlen explicit fájlt céloz). HOZZÁADÓDIK.
         const baseIgnore = await this.resolveIgnorePatterns(set.scopePath, set.exclude);
         const famIgnore = set.operation === 'scan-file' ? [] : fam_famignore_util_1.FAM_FamIgnore_Util.loadFromDir(resolvedRoot);
+        // A projektben LATHATO, verziokezelt FAM-beallitas (`.famconfig.json`) — a `.fdpfamignore` testvere.
+        // Owner-igeny 2026-08-22: a beallitasok ne CSAK a FAM-ban eljenek, hanem a projektben is latszodjanak.
+        const projectConfig = set.operation === 'scan-file'
+            ? undefined
+            : fam_project_config_util_1.FAM_ProjectConfig_Util.load(resolvedRoot);
+        if (projectConfig) {
+            fsm_dynamo_1.DyFM_Log.info(`[famIngest] ${fam_project_config_util_1.FAM_ProjectConfig_Util.FILE_NAME} betoltve (${resolvedRoot}): `
+                + `weight=${projectConfig.weight ?? '-'}, per-minta szabaly=${projectConfig.weights?.length ?? 0}`
+                + `${projectConfig.note ? ` | ${projectConfig.note}` : ''}`);
+        }
+        const projectWeightRules = fam_project_config_util_1.FAM_ProjectConfig_Util.projectWeightRules(projectConfig);
         if (famIgnore.length) {
             fsm_dynamo_1.DyFM_Log.info(`[famIngest] .fdpfamignore betöltve (${resolvedRoot}): ${famIgnore.length / 2} minta-sor`);
         }
@@ -94,6 +106,7 @@ class FAM_Scan_ControlService {
                 maxFileSizeBytes: maxFileSizeBytes,
                 tableOverride: set.tableOverride,
                 weights: set.weights,
+                projectWeightRules: projectWeightRules,
                 testFileWeight: testFileWeight,
             });
             if (routed.route === 'skip') {
@@ -154,6 +167,7 @@ class FAM_Scan_ControlService {
         return {
             ...base, route: route,
             weight: fam_scan_weight_util_1.FAM_ScanWeight_Util.resolveWithDefault(set.relativePath, set.weights, set.testFileWeight),
+            projectWeight: fam_scan_weight_util_1.FAM_ScanWeight_Util.resolve(set.relativePath, set.projectWeightRules),
         };
     }
     /**

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

@@ -66,6 +66,12 @@ 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.',
                     },
+                    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,7 @@ class FAM_ReadTool_Service {
             kindFilter: query.kindFilter,
             excludeIds: query.excludeIds,
             depth: query.depth,
+            includeCrossTableProbe: query.includeCrossTableProbe,
             // Per-query tartalom-kapcsolo atvezetese (2026-08-14 lelet: eddig itt VESZETT EL).
             includeContent: query.includeContent,
         };

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

@@ -0,0 +1,129 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FAM_CrossTableNote_Util = void 0;
+/**
+ * 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`.)
+ */
+const NON_KNOWLEDGE_KINDS = ['user_prompt', 'fs-summary'];
+const NON_KNOWLEDGE_TAGS = ['temporary_context', '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-e a jelölt (nyers user-prompt / átmeneti kontextus). Lásd a fenti mérést. */
+    static isNonKnowledge(candidate) {
+        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/_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");
@@ -112,11 +114,98 @@ 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);
         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 = [fam_table_type_enum_1.FAM_Table.memory, fam_table_type_enum_1.FAM_Table.knowledge]
+            .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.
+        const probeConfig = { ...tableConfig, topK: set.config.crossTableNoteTopK, minScore: 0 };
+        const hits = await this.searchTable({
+            table: table, query: set.query, queryVector: set.queryVector,
+            scopeExpand: set.scopeExpand, config: probeConfig, includeContent: false,
+        });
+        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.
@@ -469,12 +558,21 @@ class FAM_Retrieval_ControlService {
             })
             : 0;
         const keywordBoost = 1 + set.config.keywordWeight * lexicalScore;
+        // PROJEKT-SZINTU szorzo a `.famconfig.json`-bol — SZANDEKOSAN a temperalason KIVUL. A `weight` mezo az
+        // `effectiveWeight`-en megy at, ahonnan a 0.06-os influence mellett MAXIMUM 6% lehuzas johet (merve
+        // 2026-08-22), ezert egy projekt-szintu policy ott gyakorlatilag hatastalan lenne. Itt viszont a szorzo
+        // KOZVETLENUL hat. A rangsor RELATIV, ezert az egyenletes projekt-szorzo altalanos keresesben halkit, de
+        // scope-olt (celzott) keresesben NEM valtoztat sorrendet — minden jelolt ugyanazt a szorzot kapja.
+        const projectFactor = typeof set.entry.projectWeight === 'number'
+            && Number.isFinite(set.entry.projectWeight) && set.entry.projectWeight > 0
+            ? set.entry.projectWeight
+            : 1;
         return {
             id: set.vectorHit.id,
             table: set.table,
             score: set.vectorHit.score,
             weight: set.weight,
-            finalScore: set.vectorHit.score * FAM_Retrieval_ControlService.effectiveWeight(set.weight, set.config.weightInfluence) * chunkFactor * sourceFactor * summaryFactor * decayFactor * keywordBoost,
+            finalScore: set.vectorHit.score * FAM_Retrieval_ControlService.effectiveWeight(set.weight, set.config.weightInfluence) * chunkFactor * sourceFactor * summaryFactor * decayFactor * keywordBoost * projectFactor,
             lexicalScore: lexicalScore,
             content: set.includeContent ? set.entry.content : undefined,
             contentHash: set.entry.contentHash,
@@ -718,6 +816,12 @@ 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.
+        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 memoryReactivateValue = (await config.resolve('memory.reactivateOnRead', ctx)).value;
         const memoryReactivateOnRead = memoryReactivateValue !== false;
         const memoryColdSearchValue = (await config.resolve('memory.coldSearchEnabled', ctx)).value;
@@ -727,6 +831,10 @@ class FAM_Retrieval_ControlService {
         return {
             topK: Math.min(topKDefault, exports.MAX_PAGE_SIZE),
             minScore: minScore,
+            crossTableNoteEnabled: crossTableNoteEnabled,
+            crossTableNoteMinDelta: crossTableNoteMinDelta,
+            crossTableNoteMinScore: crossTableNoteMinScore,
+            crossTableNoteTopK: crossTableNoteTopK,
             relevanceFloor: relevanceFloor,
             importChunkWeight: importChunkWeight,
             importSourceWeight: importSourceWeight,

package/build/src/_routes/server/api/api.controller.js

@@ -69,6 +69,7 @@ class Api_Controller extends nts_dynamo_1.DyNTS_Controller {
             this.statsTableEndpoint(),
             this.ingestRunsEndpoint(),
             this.duplicatesEndpoint(),
+            this.duplicatesPruneEndpoint(),
             this.configGetEndpoint(),
             this.configSetEndpoint(),
             this.scanStartEndpoint(),
@@ -627,6 +628,36 @@ class Api_Controller extends nts_dynamo_1.DyNTS_Controller {
         });
     }
     // =========================================================================
+    // /duplicates/prune — BÁJTAZONOS ismétlés-nyesés (dry-run az alapértelmezés)
+    // =========================================================================
+    /**
+     * `POST /duplicates/prune` — az azonos `(absolutePath, chunkIndex, chunkTotal, contentHash)` négyesű
+     * példányokból a legfrissebbet megtartja, a többit soft-delete-eli, és a csoport `recallCount` /
+     * `lastRecalledAt` MAXIMUMÁT a megtartottra viszi. Body: `table` (opcionális, különben MINDEN tár),
+     * `dryRun` (DEFAULT `true` — törölni csak explicit `false`-szal lehet), `maxGroups`.
+     *
+     * A `GET /duplicates/:table`-lel NEM keverendő: az szemantikus hasonlóságot keres és sosem töröl.
+     */
+    duplicatesPruneEndpoint() {
+        return new nts_dynamo_1.DyNTS_Endpoint_Params({
+            name: 'duplicatesPrune',
+            type: fsm_dynamo_1.DyFM_HttpCallType.post,
+            endpoint: '/duplicates/prune',
+            tasks: [
+                async (req, res) => {
+                    await this.run(res, async () => {
+                        const body = req.body ?? {};
+                        return embedding_1.FAM_ExactDuplicatePrune_ControlService.getInstance().prune({
+                            table: body.table ? this.parseTable(body.table) : undefined,
+                            dryRun: body.dryRun !== false,
+                            maxGroups: typeof body.maxGroups === 'number' ? body.maxGroups : undefined,
+                        });
+                    });
+                },
+            ],
+        });
+    }
+    // =========================================================================
     // /config — scoped config olvasás/írás (dsgn-007; a UI settings + CLI config)
     // =========================================================================
     /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@futdevpro/fdp-agent-memory",
-  "version": "1.1.163",
+  "version": "1.1.177",
   "description": "Local-first, vector-backed multi-table agent memory exposed as an MCP server (read/write/capabilities). Public, FDP-Templates-free, no auth.",
   "private": false,
   "publishConfig": {
@@ -19,7 +19,13 @@
     "build",
     "client-dist",
     "README.md",
-    "LICENSE"
+    "LICENSE",
+    "!build/**/*.spec.js",
+    "!build/**/*.spec.js.map",
+    "!build/**/*.spec.d.ts",
+    "!build/**/_benchmarks/**",
+    "!build/**/_integration-tests/**",
+    "!build/**/_spec-support/**"
   ],
   "engines": {
     "node": ">=20"

package/build/src/_integration-tests/_helpers/fam-integration-test-setup.util.js

@@ -1,105 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.FAM_IntegrationTest_Setup_Util = void 0;
-const tslib_1 = require("tslib");
-const net = tslib_1.__importStar(require("net"));
-const mongoose_1 = tslib_1.__importDefault(require("mongoose"));
-const nts_dynamo_1 = require("@futdevpro/nts-dynamo");
-const fam_db_models_const_1 = require("../../_collections/fam-db-models.const");
-/** Integrációs teszt issuer — a MongoDB-dokumentumok azonosítására. */
-const INTTEST_ISSUER = 'integration-test';
-/** Teszt-adat prefix — a teszt-dokumentumok megkülönböztetésére (NEM ütközik production-nal). */
-const INTTEST_PREFIX = 'inttest-';
-/** A dedikált spec-DB neve (a runner/local Mongo-n; NEM a `fdp-agent-memory` prod-DB). */
-const INTTEST_DB_NAME = 'fam_inttest';
-/** MongoDB elérhetőség-ellenőrzés timeout (ms). */
-const MONGO_CHECK_TIMEOUT_MS = 1500;
-/**
- * `FAM_IntegrationTest_Setup_Util` — az integrációs tesztek közös setup-utility-je (a
- * `ccap-revisioned` `IntegrationTest_Setup_Util` mintára). MongoDB-elérhetőség (TCP-probe a
- * `MONGO_URL`-re), egyedi `inttest-` ID-generálás, ÉS egy **lightweight DB-setup** (mongoose-connect +
- * `DyNTS_GlobalService.setServices`) — **NEM a teljes `new App()` boot** (az HTTP-listen + LVS-hydrate
- * postProcess-t indít, ami a spec-eket hangolja); csak a DataService-ek DB-rétegét állítja fel.
- */
-class FAM_IntegrationTest_Setup_Util {
-    /** Teszt issuer azonosító — minden integrációs-teszt DataService-híváshoz. */
-    static getIssuer() {
-        return INTTEST_ISSUER;
-    }
-    /**
-     * Egyedi, időbélyeges ID/tartalom a teszt-adatokhoz. Pattern: `inttest-{timestamp}-{random}` —
-     * párhuzamos futtatásban is egyedi, és a prefix jelzi a teszt-adatot.
-     */
-    static generateUniqueId() {
-        const timestamp = Date.now();
-        const random = Math.random().toString(36).substring(2, 8);
-        return `${INTTEST_PREFIX}${timestamp}-${random}`;
-    }
-    /**
-     * MongoDB elérhetőség TCP-socket-tel (a `MONGO_URL` host:port-ja; default
-     * `mongodb://127.0.0.1:27017`). Ha nem elérhető → `false`, és a tesztek `pending()`-re állnak
-     * (CI-ben Mongo nélkül is zöld a suite — pending, NEM failure).
-     */
-    static checkMongoAvailability() {
-        return new Promise((resolve) => {
-            const mongoUrl = process.env.MONGO_URL ?? 'mongodb://127.0.0.1:27017';
-            const urlNoProtocol = mongoUrl.replace(/^mongodb(\+srv)?:\/\//, '');
-            const hostPort = urlNoProtocol.split('/')[0];
-            const parts = hostPort.split(':');
-            const host = parts[0];
-            const port = parseInt(parts[1] ?? '27017', 10);
-            const socket = net.createConnection({ host: host, port: port });
-            let finished = false;
-            const finish = (available) => {
-                if (finished) {
-                    return;
-                }
-                finished = true;
-                try {
-                    socket.destroy();
-                }
-                catch { /* ignore */ }
-                resolve(available);
-            };
-            socket.on('connect', () => { finish(true); });
-            socket.on('error', () => { finish(false); });
-            setTimeout(() => { finish(false); }, MONGO_CHECK_TIMEOUT_MS);
-        });
-    }
-    /**
-     * Lightweight DB-setup (`beforeAll`-ban, ha a Mongo elérhető): mongoose-connect a dedikált
-     * `fam_inttest` DB-re + `DyNTS_GlobalService.setServices` a `FAM_DB_MODELS`-szel (SSOT). Így a
-     * `new FAM_*_DataService(...)` (eager getDBService) feloldódik — App-boot, HTTP-listen és
-     * embedding/LVS-postProcess NÉLKÜL (azok a teljes boot velejárói, itt nem kellenek).
-     */
-    static async setupDb() {
-        const mongoUrl = process.env.MONGO_URL ?? 'mongodb://127.0.0.1:27017';
-        const base = mongoUrl.replace(/^(mongodb(\+srv)?:\/\/[^/]+).*$/, '$1');
-        await mongoose_1.default.connect(`${base}/${INTTEST_DB_NAME}`);
-        await nts_dynamo_1.DyNTS_GlobalService.setServices({ dbModels: fam_db_models_const_1.FAM_DB_MODELS });
-    }
-    /** DB-teardown (`afterAll`-ban): a mongoose-kapcsolat zárása (best-effort). */
-    static async teardownDb() {
-        try {
-            if (mongoose_1.default.connection.readyState !== 0) {
-                await mongoose_1.default.disconnect();
-            }
-        }
-        catch {
-            // best-effort — a process-vég úgyis bontja.
-        }
-    }
-    /** Egy collection ürítése teszt KÖZÖTT (a teszt-izolációhoz). No-op ha a kapcsolat nem áll. */
-    static async clearCollection(collectionName) {
-        if (mongoose_1.default.connection.readyState !== 1) {
-            return;
-        }
-        try {
-            await mongoose_1.default.connection.collection(collectionName).deleteMany({});
-        }
-        catch {
-            // a collection lehet hogy még nem létezik — nem hiba.
-        }
-    }
-}
-exports.FAM_IntegrationTest_Setup_Util = FAM_IntegrationTest_Setup_Util;