@futdevpro/fdp-agent-memory 1.1.166 → 1.1.177

package/build/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@futdevpro/fdp-agent-memory",
-    "version": "1.1.166",
+    "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/_cli/_commands/prune-duplicates.command.js

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FAM_PruneDuplicates_Util = void 0;
+const commander_1 = require("commander");
+const fam_output_util_1 = require("../_collections/fam-output.util");
+const fam_client_service_1 = require("../_services/fam-client.service");
+const fam_cli_const_1 = require("../_collections/fam-cli.const");
+/**
+ * `fam prune-duplicates [--table t] [--apply]` — BÁJTAZONOS ismétlés-nyesés.
+ *
+ * Az azonos `(absolutePath, chunkIndex, chunkTotal, contentHash)` négyesű példányok között NINCS
+ * információ-különbség: a legfrissebbet megtartjuk, a többit soft-delete-eljük, és a csoport
+ * `recallCount` / `lastRecalledAt` MAXIMUMÁT átvisszük a megtartottra (a felidézés-történet nem veszhet el).
+ *
+ * **Alapértelmezés a DRY-RUN** — a törléshez explicit `--apply` kell. A `find-duplicates`-szel NEM
+ * keverendő: az SZEMANTIKAI hasonlóságot keres (koszinusz-cluster) és szándékosan sosem töröl.
+ *
+ * `superseded` bejegyzést tartalmazó csoporthoz SOHA nem nyúl (az a `memory` tár szándékos, leváltott
+ * generációja) — a kihagyás számláltan látszik a riportban.
+ *
+ * ⏱️ **FUTÁSIDŐ (mérve 2026-09-01, 555k aktív chunk):** a TELJES korpusz **~123 s**, egyetlen tár (`rules`)
+ * **~1,4 s**. Ez egy hosszan futó, szinkron aggregáció — automatizált hívónál (CI, HTTP-kliens) vagy emeld
+ * a timeoutot, vagy `--table`-lel bontsd táranként. A `--max-groups` a MUNKÁT nem, csak a feldolgozott
+ * csoportok számát korlátozza (az aggregáció akkor is végigmegy).
+ */
+class FAM_PruneDuplicates_Util {
+    /** A `prune-duplicates` parancs-deszkriptor. */
+    static command() {
+        const command = new commander_1.Command('prune-duplicates');
+        command
+            .description('Bájtazonos ismétlés-nyesés (a legfrissebb marad; DRY-RUN az alapértelmezés)')
+            .option('--table <table>', 'csak ez a tár (default: MINDEN tár)')
+            .option('--apply', 'a nyesés TÉNYLEGES végrehajtása (enélkül csak mér, nem ír)')
+            .option('--max-groups <n>', 'csoport-plafon egy futásra (default 50000; a capped jelzi, ha több)')
+            .action(async () => {
+            fam_output_util_1.FAM_Output_Util.exit(await FAM_PruneDuplicates_Util.run(command));
+        });
+        return command;
+    }
+    /** A `prune-duplicates` futtatása a REST `POST /api/duplicates/prune`-on. */
+    static async run(command) {
+        const globals = command.optsWithGlobals();
+        const local = command.opts();
+        const client = new fam_client_service_1.FAM_CliClient_Service(globals.serverUrl);
+        const maxGroups = local.maxGroups !== undefined ? Number(local.maxGroups) : undefined;
+        const result = await client.post('/api/duplicates/prune', {
+            table: local.table,
+            // A `--apply` HIÁNYA a biztonságos irány: dryRun marad. Elgépelt kapcsoló sosem töröl.
+            dryRun: local.apply !== true,
+            maxGroups: Number.isFinite(maxGroups) ? maxGroups : undefined,
+        });
+        if (!result.ok) {
+            return fam_output_util_1.FAM_Output_Util.failure({
+                options: globals,
+                command: 'prune-duplicates',
+                error: result.error ?? { errorCode: 'FAM-CLI-PRUNE-001', message: 'Ismeretlen nyesési hiba.' },
+                exitCode: result.unreachable ? fam_cli_const_1.FAM_CliExitCode.serverUnreachable : fam_cli_const_1.FAM_CliExitCode.operationError,
+            });
+        }
+        return fam_output_util_1.FAM_Output_Util.success({
+            options: globals,
+            command: 'prune-duplicates',
+            data: result.data,
+            humanFormatter: (data) => FAM_PruneDuplicates_Util.format(data),
+        });
+    }
+    /** Ember-olvasható összegzés: per-tár sorok + összesítés + a dry-run explicit jelzése. */
+    static format(report) {
+        const lines = [];
+        lines.push(report.dryRun
+            ? 'Bájtazonos ismétlés-nyesés — DRY-RUN (semmi nem változott; a végrehajtáshoz: --apply):'
+            : 'Bájtazonos ismétlés-nyesés — VÉGREHAJTVA:');
+        for (const row of report.tables) {
+            if (!row.groups) {
+                continue;
+            }
+            lines.push(`  ${row.table.padEnd(18)} ${String(row.groups).padStart(6)} csoport`
+                + ` → ${String(row.prunedChunks).padStart(6)} chunk`
+                + `${row.recallCarried ? `, ${row.recallCarried} felidézés-történet átvive` : ''}`
+                + `${row.skippedSuperseded ? `, ${row.skippedSuperseded} superseded KIHAGYVA` : ''}`
+                + `${row.capped ? '  ⚠ CAPPED (emeld a --max-groups-ot, vagy futtasd újra)' : ''}`);
+        }
+        if (!report.totalGroups) {
+            lines.push('  ✓ nincs bájtazonos ismétlés.');
+            return lines.join('\n');
+        }
+        lines.push(`  ÖSSZESEN: ${report.totalGroups} csoport, ${report.totalPrunedChunks} felesleges chunk`
+            + `, ${report.totalRecallCarried} felidézés-történet átvive`
+            + `, ${report.totalSkippedSuperseded} superseded csoport érintetlen.`);
+        return lines.join('\n');
+    }
+}
+exports.FAM_PruneDuplicates_Util = FAM_PruneDuplicates_Util;

package/build/src/_cli/register-commands.js

@@ -8,6 +8,7 @@ const scan_projects_command_1 = require("./_commands/scan-projects.command");
 const config_command_1 = require("./_commands/config.command");
 const stats_command_1 = require("./_commands/stats.command");
 const find_duplicates_command_1 = require("./_commands/find-duplicates.command");
+const prune_duplicates_command_1 = require("./_commands/prune-duplicates.command");
 const errors_command_1 = require("./_commands/errors.command");
 const init_command_1 = require("./_commands/init.command");
 const doctor_command_1 = require("./_commands/doctor.command");
@@ -56,6 +57,7 @@ function registerFAMCommands(program, version) {
         remote_command_1.FAM_Remote_Util.command(),
         stats_command_1.FAM_Stats_Util.command(),
         find_duplicates_command_1.FAM_FindDuplicates_Util.command(),
+        prune_duplicates_command_1.FAM_PruneDuplicates_Util.command(),
         errors_command_1.FAM_Errors_Util.command(),
         // 7 delegáló alias (README copy-paste-elhetőség, nincs külön logika; dsgn-010 §10).
         doctor_command_1.FAM_Doctor_Util.aliasCommand('validate-env', ['env']),

package/build/src/_collections/config-catalog.const.js

@@ -187,6 +187,37 @@ exports.CONFIG_CATALOG = {
             + 'Mert indok (2026-08-22): kontrollalt teszten a rules tar 0/3 aranyban tunt el a documents mogott, '
             + 'holott a csak-rules query azonnal hozta a kanonikus szabalyt.',
     },
+    // KERESZT-TAR "mellesleg"-javaslat (2026-09-01). A `memory`/`knowledge` a HIBAKERESES-jellegu kerdeseken
+    // eros ("miert tort el", "lattuk mar ezt"), de az agent jellemzoen `codebase`/`documents`-ben keres, mert
+    // nem tudja, hogy ott van. Merve 15 realisztikus kerdesen: 13-nal az ELSODLEGES tar volt jobb -> a talalat
+    // NEM kerulhet a listaba (13 esetben rontanank, hogy 2-ben javitsunk), csak kulon, egyetlen mellek-mezobe.
+    'read.crossTableNoteEnabled': {
+        type: 'boolean', default: true, levels: ALL_LEVELS,
+        description: 'Kereszt-tar "mellesleg"-javaslat: ha a memory/knowledge taron ERDEMBEN erosebb talalat van, '
+            + 'a valasz kap egy kulon `crossTableNote` mezot. A `hits` VALTOZATLAN marad (sem sorrend, sem tagsag). '
+            + 'Nem fut, ha a hivo eleve kerte ezeket a tarakat. Merve: +376 ms (+14%) a szonda koltsege.',
+    },
+    'read.crossTableNoteMinDelta': {
+        type: 'number', default: 0.025, min: 0, max: 1, levels: ALL_LEVELS,
+        description: 'A megszolalashoz szukseges NYERS score-elony. 0 = kikapcsolva. Kalibralva 44 eseten, '
+            + 'KONTROLLCSOPORTTAL (24 strukturalis kerdes + 20 diagnosztikai). FONTOS: az elso kalibracio '
+            + '0,12-t adott, de kiderult, hogy a magas deltakat szinte kizarolag beszelgetes-tormelek '
+            + '(user_prompt / temporary_context, a memory tar 20,2%-a) termelte. A tormelek kizarasa utan '
+            + '0,12-nel a jegyzet SOHA nem szolalt volna meg. A valos jel a 0,025-0,06 savban van, es ott '
+            + 'pontos: 3/44 megszolalas (6,8%), koztuk a docker-cache-token es a lokal-vs-CI tanulsag. '
+            + 'KORLAT: ket kulonbozo tartalomtipus nyers koszinuszat hasonlitja -> korpusz-valtaskor UJRA KELL MERNI '
+            + '(`node build/src/_benchmarks/fam-crosstable-bench.js`).',
+    },
+    'read.crossTableNoteMinScore': {
+        type: 'number', default: 0.45, min: 0, max: 1, levels: ALL_LEVELS,
+        description: 'Abszolut also korlat a jelolt sajat score-jara: gyenge talalatot akkor sem ajanlunk, '
+            + 'ha az elsodleges tar meg gyengebb (kulonben a "nincs talalat" eset minden alkalommal zajt szulne).',
+    },
+    'read.crossTableNoteTopK': {
+        type: 'number', default: 3, min: 1, max: 10, integer: true, levels: ALL_LEVELS,
+        description: 'A szonda topK-ja taranként. Kicsi: a szonda csak azt donti el, VAN-E erdemben erosebb — '
+            + 'nem masodik talalati listat epit.',
+    },
     'read.relevanceFloor': {
         type: 'number', default: 0.60, min: 0.0, max: 1.0, levels: ALL_LEVELS,
         // PER-TÁR kalibráció (2026-08-14 MÉRÉS): a tárak score-tartománya ELTÉR — a `codebase`/`documents` szimbólum-

package/build/src/_modules/embedding/_collections/fam-exact-duplicate-prune.util.js

@@ -0,0 +1,85 @@
+"use strict";
+/**
+ * PONTOS (bájtazonos) ismétlés-nyesés — a döntési logika, tisztán és tesztelhetően.
+ *
+ * **Miben más ez, mint a `FAM_DuplicateScan_ControlService`?** Az a SZEMANTIKAI hasonlóságot keresi
+ * (koszinusz-cluster) és szándékosan sosem töröl — ott emberi ítélet kell. EZ viszont a BIZONYÍTOTTAN
+ * AZONOS újra-beolvasást nyesi: azonos `(source.absolutePath, chunkIndex, chunkTotal, contentHash)` →
+ * a példányok között NINCS információ-különbség, így az elhagyásuk nem veszteség.
+ *
+ * **Mért indok (2026-09-01):** egy projekt-átnevezés után a heti re-scan cél-uniója MINDKÉT nevet
+ * megtartotta ugyanarra a mappára, a delta-összevetés pedig a levél-scopeId-re szűrt — így a második
+ * menet üres `existing`-et kapott, és mindent `new`-ként vitt be. Az aktív korpuszban ez **13 201**
+ * felesleges chunk (a 555 102 aktívból 2,38%). A gyökér-okot a scope-vak fallback + az útvonal-dedup
+ * javítja; EZ a maradék takarítása.
+ *
+ * **Amihez SOHA nem nyúl:**
+ *  - `superseded` bejegyzés — az a `memory` tár szándékos, leváltott generációja (dsgn-013 MAM F4),
+ *    az owner explicit kérése szerint MEGMARAD („nem baj ha fennmarad olyan memória amit a Claude már
+ *    elfelejtett… sőt!"). Mérve: a `memory` táron 0 bájtazonos csoport van, mind a 287 eltérő tartalmú.
+ *  - ELTÉRŐ `contentHash`-ű példányok — azok valódi tartalom-történet, nem ismétlés (mérve 3 046 csoport).
+ *
+ * **Megőrzött felidézés-történet:** a csoport `recallCount` / `lastRecalledAt` MAXIMUMA a megtartott
+ * példányra vándorol — az owner „amit többet használtunk, az tovább él" elve nem sérülhet a nyesésben.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FAM_ExactDuplicatePrune_Util = void 0;
+class FAM_ExactDuplicatePrune_Util {
+    /**
+     * A megtartandó példány: a LEGFRISSEBB `lastModified`. Döntetlennél a lexikálisan legnagyobb `id`
+     * nyer — nem esztétika, hanem DETERMINIZMUS: a nyesés kétszer futtatva ugyanazt kell adja, különben
+     * a második futás megint mozgatna, és a művelet nem lenne idempotens.
+     */
+    static chooseKeeper(members) {
+        if (!members.length) {
+            return undefined;
+        }
+        return [...members].sort((a, b) => {
+            const at = typeof a.lastModified === 'number' ? a.lastModified : 0;
+            const bt = typeof b.lastModified === 'number' ? b.lastModified : 0;
+            return bt !== at ? bt - at : (a.id < b.id ? 1 : -1);
+        })[0];
+    }
+    /** A csoport felidézés-történetének maximuma (a megtartottra vitt érték bemenete). */
+    static maxRecall(members) {
+        let count = 0;
+        let at = 0;
+        for (const member of members) {
+            if (typeof member.recallCount === 'number' && member.recallCount > count) {
+                count = member.recallCount;
+            }
+            if (typeof member.lastRecalledAt === 'number' && member.lastRecalledAt > at) {
+                at = member.lastRecalledAt;
+            }
+        }
+        return { recallCount: count, lastRecalledAt: at };
+    }
+    /**
+     * Egy csoport nyesési terve — vagy a kihagyás INDOKA. A `carry` csak azt a mezőt tartalmazza, ami a
+     * megtartotton ténylegesen NŐNE: fölösleges írást nem kérünk, és a keeper saját értékét sem rontjuk le.
+     */
+    static planGroup(members) {
+        if (members.length < 2) {
+            return 'single-member';
+        }
+        if (members.some((member) => member.superseded === true)) {
+            return 'superseded-present';
+        }
+        const keeper = FAM_ExactDuplicatePrune_Util.chooseKeeper(members);
+        const max = FAM_ExactDuplicatePrune_Util.maxRecall(members);
+        const carry = {};
+        if (max.recallCount > (keeper.recallCount ?? 0)) {
+            carry.recallCount = max.recallCount;
+        }
+        if (max.lastRecalledAt > (keeper.lastRecalledAt ?? 0)) {
+            carry.lastRecalledAt = max.lastRecalledAt;
+        }
+        return {
+            keepId: keeper.id,
+            dropIds: members.filter((member) => member.id !== keeper.id)
+                .map((member) => member.id),
+            carry: carry,
+        };
+    }
+}
+exports.FAM_ExactDuplicatePrune_Util = FAM_ExactDuplicatePrune_Util;

package/build/src/_modules/embedding/_services/fam-entry.data-service.js

@@ -156,6 +156,27 @@ class FAM_Entry_DataService extends nts_dynamo_1.DyNTS_DataService {
         filterBy['source.root'] = { $ne: root };
         await this.updateData({ filterBy: filterBy, update: update });
     }
+    /**
+     * A `scopePath` FELTÉTELES backfill-je (2026-09-01) — a re-scan `equal` ágán hívva.
+     *
+     * **Miért kell.** A fájl IDENTITÁSA az abszolút útvonal, a scope csak besorolás — ezért az `equal`
+     * összevetés (a scope-vak fallback óta) MÁS scope alatt álló chunkot is adoptál. Enélkül a backfill
+     * nélkül az adoptált chunk ÖRÖKRE a RÉGI projekt-név alatt maradna: a duplikáció megszűnne, de a
+     * scope-szűrt keresés az ÚJ néven nem találná meg. A régi viselkedés (teljes duplikálás) legalább
+     * hagyott egy példányt az új scope alatt — a javítás enélkül CSERÉLNE egy hibát egy másikra.
+     *
+     * Csak akkor ír, ha a LEVÉL scopeId eltér (no-op, ha már stimmel).
+     */
+    async backfillScopePath(id, scopePath) {
+        if (!scopePath.length) {
+            return;
+        }
+        const leafScopeId = scopePath[scopePath.length - 1].scopeId;
+        const update = { $set: { scopePath: scopePath } };
+        const filterBy = { _id: id };
+        filterBy['scopePath.scopeId'] = { $ne: leafScopeId };
+        await this.updateData({ filterBy: filterBy, update: update });
+    }
     /**
      * A `sourceFilePath` (display-relatív út) FELTÉTELES backfill-je (FAM-REV-050) — a re-scan `equal` ágán
      * hívva, hogy a default (basePath-nélküli) relatív út KONZISZTENS legyen, miután a fájl-identitás az

package/build/src/_modules/embedding/_services/fam-exact-duplicate-prune.control-service.js

@@ -0,0 +1,152 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FAM_ExactDuplicatePrune_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_entry_data_service_1 = require("./fam-entry.data-service");
+const fam_exact_duplicate_prune_util_1 = require("../_collections/fam-exact-duplicate-prune.util");
+const fam_store_registry_const_1 = require("../_collections/fam-store-registry.const");
+const fam_vector_search_control_service_1 = require("./fam-vector-search.control-service");
+const DEFAULT_MAX_GROUPS = 50000;
+/**
+ * BÁJTAZONOS ismétlés-nyesés (2026-09-01). Azonos `(absolutePath, chunkIndex, chunkTotal, contentHash)`
+ * → a példányok között NINCS információ-különbség; a legfrissebbet tartjuk, a többit soft-delete-eljük.
+ *
+ * **Nem keverendő** a `FAM_DuplicateScan_ControlService`-szel: az SZEMANTIKAI hasonlóságot keres és
+ * sosem töröl (ott emberi ítélet kell). A kritériumok és a kivételek indoklása a pure utilban áll.
+ *
+ * A soft-delete DIREKT `_deleted` (nem `deleteData`) — a FAM entry-tárak `addArchive:true`-ok, így a
+ * per-entry törlés minden példányról ARCHÍV-másolatot csinálna (bloat + lassú tízezres nagyságrenden).
+ * Ugyanez a döntés a scope-reset ágon is (`fam-scope-maintenance.control-service.ts`).
+ */
+class FAM_ExactDuplicatePrune_ControlService {
+    static _instance;
+    static getInstance() {
+        if (!FAM_ExactDuplicatePrune_ControlService._instance) {
+            FAM_ExactDuplicatePrune_ControlService._instance = new FAM_ExactDuplicatePrune_ControlService();
+        }
+        return FAM_ExactDuplicatePrune_ControlService._instance;
+    }
+    /** A nyesés futtatása — `dryRun` esetén CSAK mér, semmit nem ír. */
+    async prune(input = {}) {
+        const dryRun = input.dryRun !== false;
+        const maxGroups = typeof input.maxGroups === 'number' && input.maxGroups > 0
+            ? Math.floor(input.maxGroups) : DEFAULT_MAX_GROUPS;
+        const targets = input.table
+            ? [fam_store_registry_const_1.FAM_StoreRegistry_Util.getEntry(input.table)].filter(Boolean)
+            : fam_store_registry_const_1.FAM_STORE_REGISTRY;
+        const tables = [];
+        for (const registryEntry of targets) {
+            const result = await this.pruneTable(registryEntry, dryRun, maxGroups);
+            if (result) {
+                tables.push(result);
+            }
+        }
+        const sum = (pick) => tables.reduce((acc, row) => acc + pick(row), 0);
+        return {
+            operation: 'prune_exact_duplicates',
+            dryRun: dryRun,
+            tables: tables,
+            totalGroups: sum((row) => row.groups),
+            totalPrunedChunks: sum((row) => row.prunedChunks),
+            totalRecallCarried: sum((row) => row.recallCarried),
+            totalSkippedSuperseded: sum((row) => row.skippedSuperseded),
+        };
+    }
+    /** Egy tár nyesése. A modell példányosítása regisztrálja a mongoose-modellt (a raw collection eléréséhez). */
+    async pruneTable(registryEntry, dryRun, maxGroups) {
+        new fam_entry_data_service_1.FAM_Entry_DataService({ dataParams: registryEntry.dataParams, issuer: 'exact-duplicate-prune' });
+        const collection = mongoose_1.default.models[registryEntry.dataParams.dataName]?.collection;
+        if (!collection) {
+            return undefined;
+        }
+        const groups = await collection.aggregate([
+            {
+                $match: {
+                    _deleted: null,
+                    'source.absolutePath': { $exists: true, $ne: null },
+                    chunkTotal: { $gt: 0 },
+                    contentHash: { $exists: true, $ne: null },
+                },
+            },
+            {
+                $group: {
+                    _id: { path: '$source.absolutePath', index: '$chunkIndex', total: '$chunkTotal', hash: '$contentHash' },
+                    count: { $sum: 1 },
+                    members: {
+                        $push: {
+                            id: '$_id',
+                            // A `__lastModified` Date — a tiszta util számot vár, ezért itt konvertáljuk (hiány → null).
+                            lastModified: { $convert: { input: '$__lastModified', to: 'long', onError: null, onNull: null } },
+                            recallCount: '$recallCount',
+                            lastRecalledAt: '$lastRecalledAt',
+                            superseded: '$superseded',
+                        },
+                    },
+                },
+            },
+            { $match: { count: { $gt: 1 } } },
+            { $limit: maxGroups + 1 },
+        ], { allowDiskUse: true }).toArray();
+        const capped = groups.length > maxGroups;
+        const work = capped ? groups.slice(0, maxGroups) : groups;
+        let prunedChunks = 0;
+        let recallCarried = 0;
+        let skippedSuperseded = 0;
+        for (const group of work) {
+            // A nyers `_id`-t megőrizzük (ObjectId VAGY string lehet) — a util string-kulcsot lát, a DB a nyerset kapja.
+            const byKey = new Map();
+            const members = group.members.map((raw) => {
+                const key = String(raw.id);
+                byKey.set(key, raw.id);
+                return {
+                    id: key,
+                    lastModified: typeof raw.lastModified === 'number' ? raw.lastModified : undefined,
+                    recallCount: raw.recallCount,
+                    lastRecalledAt: raw.lastRecalledAt,
+                    superseded: raw.superseded,
+                };
+            });
+            const plan = fam_exact_duplicate_prune_util_1.FAM_ExactDuplicatePrune_Util.planGroup(members);
+            if (typeof plan === 'string') {
+                if (plan === 'superseded-present') {
+                    skippedSuperseded++;
+                }
+                continue;
+            }
+            prunedChunks += plan.dropIds.length;
+            const hasCarry = Object.keys(plan.carry).length > 0;
+            if (hasCarry) {
+                recallCarried++;
+            }
+            if (dryRun) {
+                continue;
+            }
+            const dropRaw = plan.dropIds.map((id) => byKey.get(id));
+            await collection.updateMany({ _id: { $in: dropRaw } }, { $set: { _deleted: new Date() } });
+            if (hasCarry) {
+                // A felidézés-történet MAXIMUMA a megtartottra — az owner "amit többet használtunk, az tovább
+                // él" elve nem sérülhet attól, hogy épp a ritkábban felidézett példány a legfrissebb.
+                await collection.updateOne({ _id: byKey.get(plan.keepId) }, { $set: plan.carry });
+            }
+            for (const id of plan.dropIds) {
+                fam_vector_search_control_service_1.FAM_VectorSearch_ControlService.getInstance().removeVector(registryEntry.table, id);
+            }
+        }
+        if (capped) {
+            fsm_dynamo_1.DyFM_Log.warn(`[prune-duplicates] ${registryEntry.table}: a csoport-plafon (${maxGroups}) elerve — `
+                + 'a riport `capped: true`-t ad, tovabbi futas szukseges (nincs nema csonkolas).');
+        }
+        return {
+            table: registryEntry.table,
+            collection: collection.collectionName,
+            groups: work.length,
+            prunedChunks: prunedChunks,
+            recallCarried: recallCarried,
+            skippedSuperseded: skippedSuperseded,
+            capped: capped,
+        };
+    }
+}
+exports.FAM_ExactDuplicatePrune_ControlService = FAM_ExactDuplicatePrune_ControlService;

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/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.
@@ -727,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;
@@ -736,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.166",
+  "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;