@futdevpro/fdp-agent-memory 1.1.21 → 1.1.112

package/build/src/_modules/mcp/_services/fam-capability-registry.service.js

@@ -310,6 +310,51 @@ class FAM_CapabilityRegistry_Service {
                 return this.ok(await this.getActiveRules(this.asScopeLayers(input.scopePath), input.includeContent !== false));
             },
         });
+        // detect_code_duplication (user-FR 2026-07-15 — fleet-duplikáció → bedrock-konszolidáció): a meglévő
+        // near-duplikátum motor (FAM_DuplicateScan_ControlService) CÉLZOTT, cross-project módban. A szűrők
+        // Mongo-prefilterként szűkítik a jelölt-halmazt (a 286k-s codebase táron is futtatható célzott scan),
+        // a `minProjects` (default 2) a cross-project clusterekre fókuszál. Read-only.
+        this.register({
+            name: 'detect_code_duplication', category: category,
+            description: 'CROSS-PROJECT kód-duplikáció FELDERÍTÉS (read-only; user-FR 2026-07-15): embedding-'
+                + 'similarity near-duplikátum clusterek egy tárban (default `codebase`), projekt-lefedettséggel '
+                + '(cluster → érintett projektek + fájlok + snippet) — a bedrock-konszolidáció döntés-előkészítője. '
+                + 'A szűrők (pathRegex/excludePathRegex/excludeRootRegex/projects/excludeProjects) Mongo-prefilterként '
+                + 'szűkítik a jelölt-halmazt MÉG a vektor-számítás előtt → a nagy táron CÉLZOTT scan-t futtass '
+                + '(pl. pathRegex egy fájl-mintára + excludeRootRegex a STALE/fork zajra). A `minProjects` (default 2) '
+                + 'csak a legalább ennyi KÜLÖNBÖZŐ projektet átfedő clustereket adja. A `capped` jelzi, ha a '
+                + 'jelölt-halmaz a `maxEntries`-nél nagyobb (emeld, vagy szűkíts tovább). A `threshold` default 0.93 '
+                + '(a drift-elt másolatok elkapásához lazább, mint a general 0.95).',
+            inputSchema: this.objectSchema({
+                table: this.tableSchema(false),
+                threshold: { type: 'number', description: 'Koszinusz-küszöb 0..1 (default 0.93).' },
+                neighbors: { type: 'number', description: 'Szomszéd-szám/entry (default 10).' },
+                maxEntries: { type: 'number', description: 'Jelölt-cap az O(n²) ellen (default 3000; a capped jelzi, ha több a jelölt).' },
+                maxClusters: { type: 'number', description: 'A visszaadott clusterek max száma (default 100).' },
+                pathRegex: { type: 'string', description: 'A sourceFilePath include-regexe (case-insensitive; pl. "\\\\.(ts|scss)$").' },
+                excludePathRegex: { type: 'string', description: 'A sourceFilePath exclude-regexe (pl. "\\\\.spec\\\\.ts$|node_modules").' },
+                excludeRootRegex: { type: 'string', description: 'A source.root exclude-regexe (pl. "STALE-projects").' },
+                projects: { type: 'array', items: { type: 'string' }, description: 'Csak ezek a projektek (scopePath project-layer canonicalName).' },
+                excludeProjects: { type: 'array', items: { type: 'string' }, description: 'Kizárt projektek (fork-zaj — pl. ccap — elnyomása).' },
+                minProjects: { type: 'number', description: 'Csak a legalább ennyi KÜLÖNBÖZŐ projektet átfedő clusterek (default 2).' },
+            }),
+            handler: async (args) => {
+                const input = this.asObject(args);
+                return this.ok(await embedding_1.FAM_DuplicateScan_ControlService.getInstance().scan({
+                    table: (this.optionalTable(input.table) ?? fam_table_type_enum_1.FAM_Table.codebase),
+                    threshold: this.asNumber(input.threshold) ?? 0.93,
+                    neighbors: this.asNumber(input.neighbors),
+                    maxEntries: this.asNumber(input.maxEntries),
+                    maxClusters: this.asNumber(input.maxClusters),
+                    pathRegex: this.asString(input.pathRegex),
+                    excludePathRegex: this.asString(input.excludePathRegex),
+                    excludeRootRegex: this.asString(input.excludeRootRegex),
+                    projects: this.asStringArray(input.projects),
+                    excludeProjects: this.asStringArray(input.excludeProjects),
+                    minProjects: this.asNumber(input.minProjects) ?? 2,
+                }));
+            },
+        });
     }
     /** maintenance → MP-2 (re-embed) + MP-3 (rebuild reference index). */
     registerMaintenance() {
@@ -347,7 +392,7 @@ class FAM_CapabilityRegistry_Service {
         });
         this.register({
             name: 'export_authored', category: category,
-            description: 'FEAT-007: a non-file-derived (kézzel/agent-írt, `source.type ∈ {manual, agent}`) bejegyzések '
+            description: 'FEAT-007: a non-file-derived (kézzel/agent-írt, `source.type ∈ {manual: manual, agent: agent}`) bejegyzések '
                 + 'exportja MINDEN tárból — a re-scan-nel NEM regenerálható, pótolhatatlan kurált érték biztonsági '
                 + 'mentése (a `contentVector` nélkül; a hívó/CLI JSON-fájlba írja).',
             inputSchema: this.objectSchema({}),
@@ -393,6 +438,138 @@ class FAM_CapabilityRegistry_Service {
             }),
             handler: async (args) => this.ok(await this.manageReference(this.asObject(args))),
         });
+        this.register({
+            name: 'rename_scope', category: category,
+            description: 'Egy scope ÁTNEVEZÉSE (user-FR): a `canonicalName`-t a denormalizált scopePath-okon (MINDEN '
+                + 'RAG-entry) + a reference-en + a scope-doc-on bulk-ban átírja (a scopeId VÁLTOZATLAN). A scope '
+                + 'megadható `scopeId`-val VAGY `canonicalName`(+`layer`)-rel. **`dryRun:true` (DEFAULT) csak az érintett-'
+                + 'számot adja, NEM ír**; a tényleges íráshoz `dryRun:false` explicit. Nagy átírás után szerver-restart '
+                + 'ajánlott a LVS-pool friss scope-metaadatához.',
+            inputSchema: this.objectSchema({
+                scopeId: { type: 'string', description: 'A scope _id-ja (egyértelmű azonosítás).' },
+                layer: { type: 'string', description: 'Opcionális layer a canonicalName egyértelműsítéséhez.' },
+                canonicalName: { type: 'string', description: 'A scope JELENLEGI neve (scopeId helyett).' },
+                newName: { type: 'string', description: 'Az ÚJ canonicalName — KÖTELEZŐ.' },
+                dryRun: { type: 'boolean', description: 'true (default): csak preview; false: ír.' },
+            }),
+            handler: async (args) => {
+                const input = this.asObject(args);
+                return this.ok(await scope_reference_1.FAM_ScopeMaintenance_ControlService.getInstance().renameScope({
+                    scopeId: this.asString(input.scopeId),
+                    layer: this.asString(input.layer),
+                    canonicalName: this.asString(input.canonicalName),
+                    newName: this.asString(input.newName) ?? '',
+                    dryRun: input.dryRun !== false,
+                }));
+            },
+        });
+        this.register({
+            name: 'merge_scopes', category: category,
+            description: 'Két scope ÖSSZEOLVASZTÁSA (user-FR): a `from` scope MINDEN entry-je az `into` scope-ra mutat '
+                + '(scopePath + reference átírva), majd a `from` scope soft-delete (az `into` MARAD). from/into megadható '
+                + '`...ScopeId`-val VAGY `...Name`(+`...Layer`)-rel. **`dryRun:true` (DEFAULT) csak az érintett-számot, NEM '
+                + 'ír**; `dryRun:false` ír. NEM dedup-ol (a content-hash-összevonás a `deduplicate_entries`). Nagy merge '
+                + 'után szerver-restart ajánlott.',
+            inputSchema: this.objectSchema({
+                fromScopeId: { type: 'string', description: 'A FORRÁS scope _id-ja.' },
+                fromName: { type: 'string', description: 'A forrás scope neve (scopeId helyett).' },
+                fromLayer: { type: 'string', description: 'Opcionális forrás-layer az egyértelműsítéshez.' },
+                intoScopeId: { type: 'string', description: 'A CÉL scope _id-ja (ebbe olvad).' },
+                intoName: { type: 'string', description: 'A cél scope neve (scopeId helyett).' },
+                intoLayer: { type: 'string', description: 'Opcionális cél-layer az egyértelműsítéshez.' },
+                dryRun: { type: 'boolean', description: 'true (default): csak preview; false: ír.' },
+                force: { type: 'boolean', description: 'A cross-project merge-guard felülírása (KÜLÖNBÖZŐ projekt-gyökerek '
+                        + 'esetén is enged) — csak tudatos user-akcióra.' },
+            }),
+            handler: async (args) => {
+                const input = this.asObject(args);
+                return this.ok(await scope_reference_1.FAM_ScopeMaintenance_ControlService.getInstance().mergeScopes({
+                    from: { scopeId: this.asString(input.fromScopeId), canonicalName: this.asString(input.fromName), layer: this.asString(input.fromLayer) },
+                    into: { scopeId: this.asString(input.intoScopeId), canonicalName: this.asString(input.intoName), layer: this.asString(input.intoLayer) },
+                    dryRun: input.dryRun !== false,
+                    force: input.force === true,
+                }));
+            },
+        });
+        this.register({
+            name: 'reset_scope', category: category,
+            description: 'Egy scope SCAN-eredetű entry-jeinek TÖRLÉSE (recovery egy félre-routolt scan után). A '
+                + '`sourceType` default `scan` → a manuális/agent/import-SZERZETT (pótolhatatlan) tartalmat SOHA nem '
+                + 'törli (csak az újra-szkennelhető scan-chunkokat). Opcionális `sourceRootContains`: a `source.root` '
+                + 'substring-szűrője a SEBÉSZI cross-root takarításhoz (pl. a `ccap-revisioned` gyökerű szennyezés a '
+                + '`ccap-client` scope-ból, a `ccap` saját entry-jeinek MEGTARTÁSÁVAL). **`dryRun:true` (DEFAULT) csak a '
+                + 'per-collection számot + a `rootSamples`-t adja (verifikáció: jó scope/gyökér?), NEM ír**; a tényleges '
+                + 'soft-delete (+ LVS-pool-kivétel) `dryRun:false`. A scope `scopeId`-val VAGY `canonicalName`(+`layer`)-rel.',
+            inputSchema: this.objectSchema({
+                scopeId: { type: 'string', description: 'A scope _id-ja (egyértelmű azonosítás).' },
+                canonicalName: { type: 'string', description: 'A scope neve (scopeId helyett).' },
+                layer: { type: 'string', description: 'Opcionális layer a canonicalName egyértelműsítéséhez.' },
+                sourceType: { type: 'string', description: 'A törlendő entry-k source.type-ja (default `scan`; a manuális/agent/import VÉDETT).' },
+                sourceRootContains: { type: 'string', description: 'Opcionális: csak az e substring-et tartalmazó `source.root`-ú entry-ket (sebészi cross-root takarítás).' },
+                table: this.tableSchema(false),
+                dryRun: { type: 'boolean', description: 'true (default): preview (szám + rootSamples); false: soft-delete + pool-kivétel.' },
+            }),
+            handler: async (args) => {
+                const input = this.asObject(args);
+                return this.ok(await scope_reference_1.FAM_ScopeMaintenance_ControlService.getInstance().resetScope({
+                    scopeId: this.asString(input.scopeId),
+                    canonicalName: this.asString(input.canonicalName),
+                    layer: this.asString(input.layer),
+                    sourceType: this.asString(input.sourceType),
+                    sourceRootContains: this.asString(input.sourceRootContains),
+                    table: this.asString(input.table),
+                    dryRun: input.dryRun !== false,
+                }));
+            },
+        });
+        this.register({
+            name: 'detect_scope_issues', category: category,
+            description: 'Scope-integritás SELF-CHECK (user-FR): felismeri az ÁRVA projekt-scope-okat (layer=project, de '
+                + 'nincs org-parent — tipikusan import-eredetű lapos scope) + a DUPLIKÁTUMOKAT (ugyanaz a name+layer '
+                + 'többször), entry-számmal. CSAK OLVAS (a takarítás a `merge_scopes`). A nagyobb/parented a javasolt `into`.',
+            inputSchema: this.objectSchema({}),
+            handler: async () => this.ok(await scope_reference_1.FAM_ScopeMaintenance_ControlService.getInstance().detectIssues()),
+        });
+        this.register({
+            name: 'suggest_scope_merges', category: category,
+            description: 'Scope-merge JAVASLATOK (user-FR — auto-felismerés AKCIONÁLHATÓVÁ): a `detect_scope_issues` '
+                + 'leleteiből KONKRÉT, futtatható `merge_scopes from→into` direktívák. A REPO-KULCS-csoportok elsőbbséget '
+                + 'élveznek (a KÜLÖNBÖZŐ nevű, AZONOS repo eseteket — pl. import-`10.3.3` vs scan-`ccap-revisioned` — is '
+                + 'elkapja, amit a puszta név-egyezés kihagy); az `into` a parented/legtöbb-entry-jű scope. CSAK OLVAS — '
+                + 'a tényleges összeolvasztáshoz futtasd a javasolt `merge_scopes` hívásokat.',
+            inputSchema: this.objectSchema({}),
+            handler: async () => this.ok(await scope_reference_1.FAM_ScopeMaintenance_ControlService.getInstance().suggestMerges()),
+        });
+        this.register({
+            name: 'set_global_rule', category: category,
+            description: 'GLOBÁLIS HARD-RULE jelölés (user-FR — a FAM fő feature-je): a megadott `rules`-bejegyzéseken '
+                + 'a `globalRule` flag BE-/KIkapcsolása. A `globalRule:true` rule-ok MINDEN scope-szűrt `rules`-lekérdezésbe '
+                + 'BEKERÜLNEK (scope-tól függetlenül) → a workspace-szintű hard-rules öröklődnek minden al-scope-ba. '
+                + 'Szelektor (legalább egy): `ids` (entry-_id-k) VAGY `scopeFilter` (egy scope subtree MINDEN rule-ja, '
+                + '`[{layer,rawName}]`) VAGY `tags`. `global` (default true) = jelölés / false = visszavonás. `dryRun` → csak szám.',
+            inputSchema: this.objectSchema({
+                ids: { type: 'array', items: { type: 'string' } },
+                scopeFilter: { type: 'array', items: this.objectSchema({ layer: { type: 'string' }, rawName: { type: 'string' } }) },
+                tags: { type: 'array', items: { type: 'string' } },
+                global: { type: 'boolean' },
+                dryRun: { type: 'boolean' },
+            }),
+            handler: async (args) => {
+                const input = this.asObject(args);
+                return this.ok(await retrieval_1.FAM_GlobalRule_ControlService.getInstance().setGlobalRule({
+                    ids: Array.isArray(input.ids) ? input.ids.map((value) => String(value)) : undefined,
+                    scopeFilter: Array.isArray(input.scopeFilter)
+                        ? input.scopeFilter.map((layer) => {
+                            const obj = this.asObject(layer);
+                            return { layer: this.asString(obj.layer), rawName: this.asString(obj.rawName) };
+                        })
+                        : undefined,
+                    tags: Array.isArray(input.tags) ? input.tags.map((value) => String(value)) : undefined,
+                    global: typeof input.global === 'boolean' ? input.global : undefined,
+                    dryRun: input.dryRun === true,
+                }));
+            },
+        });
         // repair_scope_links / deduplicate_entries (MP-12) — DRY-RUN-ONLY MVP1 (safe). A destruktív
         // write-ág (entry-mutáció / soft-delete-összevonás) BACKLOG: vak destruktív bulk-op TILOS
         // (dsgn-003 §4.2), ezért a `dryRun:false` kérés clear "BACKLOG" hibát ad — a `dryRun:true` (default)
@@ -415,16 +592,18 @@ class FAM_CapabilityRegistry_Service {
         this.register({
             name: 'deduplicate_entries', category: category,
             description: 'Duplikált entry-k AUDITja: contentHash-alapú dup-csoportok feltárása (a megtartandó + a '
-                + 'beolvasztható jelöltek). DRY-RUN MVP1: riportál, NEM ír. A tényleges összevonás (soft-delete) '
+                + 'beolvasztható jelöltek), a LEGNAGYOBB csoportok elöl (+ `totalGroups`/`truncated` — nincs néma '
+                + 'csonkolás). DRY-RUN MVP1: riportál, NEM ír. A tényleges összevonás (soft-delete) '
                 + 'BACKLOG — `dryRun:false` → clear BACKLOG-hiba (vak destruktív op TILOS).',
             inputSchema: this.objectSchema({
                 table: this.tableSchema(false),
+                maxGroups: { type: 'number', description: 'A visszaadott dup-csoportok max száma (default 500; a legnagyobbak elöl).' },
                 dryRun: { type: 'boolean', description: 'MVP1: mindig true (az összevonás BACKLOG). false → BACKLOG-hiba.' },
             }),
             handler: async (args) => {
                 const input = this.asObject(args);
                 this.assertDryRunOnly(input.dryRun, 'deduplicate_entries', 'duplikátum-összevonás (soft-delete)');
-                return this.ok(await this.deduplicateEntriesDryRun(this.optionalTable(input.table)));
+                return this.ok(await this.deduplicateEntriesDryRun(this.optionalTable(input.table), this.asNumber(input.maxGroups)));
             },
         });
     }
@@ -457,7 +636,7 @@ class FAM_CapabilityRegistry_Service {
         this.register({
             name: 'import_claude_mem', category: category,
             description: 'A claude-mem migráció tényleges beírása egy import-batch (batchId) alatt: dedup-skip + '
-                + 'map + persist + embed. Output: { ok, batchId, ingested, skipped, failed, byTable, status } (dsgn-009 §5.3).',
+                + 'map + persist + embed. Output: { ok: ok, batchId: batchId, ingested: ingested, skipped: skipped, failed: failed, byTable: byTable, status: status } (dsgn-009 §5.3).',
             inputSchema: this.importMapSchema(), handler: runHandler,
         });
         this.register({
@@ -556,7 +735,10 @@ class FAM_CapabilityRegistry_Service {
     // =========================================================================
     // Wired handler-helpers (delegálás az engine-ekre)
     // =========================================================================
-    /** Per-tár statisztika (aktív elem-szám + embedding-státusz bontás) — MP-1. */
+    /**
+     * Per-tár statisztika (aktív elem-szám + embedding-státusz bontás) — MP-1.
+     * FIX (OOM): `countDocuments` + `$group`-aggregáció — NEM tölti a doc-okat memóriába (a 126k-vektoros load OOM-ozott).
+     */
     async tableStats(table) {
         const tables = table ? [table] : MAIN_TABLES;
         const result = [];
@@ -565,14 +747,22 @@ class FAM_CapabilityRegistry_Service {
             if (!registryEntry) {
                 continue;
             }
-            const dataService = new embedding_1.FAM_Entry_DataService({ dataParams: registryEntry.dataParams, issuer: this.issuer });
-            const entries = await dataService.findHydratableList({});
+            const collection = this.entryCollection(registryEntry);
+            const count = await collection.countDocuments({});
             const byStatus = { pending: 0, completed: 0, error: 0 };
-            for (const entry of entries) {
-                const status = entry.embeddingStatus ?? 'pending';
-                byStatus[status] = (byStatus[status] ?? 0) + 1;
+            const grouped = await collection
+                .aggregate([{ $group: { _id: '$embeddingStatus', n: { $sum: 1 } } }])
+                .toArray();
+            for (const group of grouped) {
+                const status = group._id ?? 'pending';
+                if (status in byStatus) {
+                    byStatus[status] += group.n;
+                }
+                else {
+                    byStatus.pending += group.n;
+                }
             }
-            result.push({ table: target, count: entries.length, embeddingStatus: byStatus });
+            result.push({ table: target, count: count, embeddingStatus: byStatus });
         }
         return table ? result[0] ?? { table: table, count: 0 } : result;
     }
@@ -618,7 +808,7 @@ class FAM_CapabilityRegistry_Service {
     /** Egy env-változó jelenlét-ellenőrzése (`treatDefaultAsPresent`: van builtin default, ezért sosem hiányzik). */
     checkEnv(name, hint, present, missing, treatDefaultAsPresent = false) {
         const value = process.env[name];
-        if ((value && value.trim().length) || treatDefaultAsPresent) {
+        if ((value?.trim().length) || treatDefaultAsPresent) {
             present.push(name);
             return;
         }
@@ -750,11 +940,10 @@ class FAM_CapabilityRegistry_Service {
      */
     async storageUsage() {
         const collections = [];
-        // Fő RAG-tárak (a store-registry-n át, a per-tár dataParams-szal).
+        // Fő RAG-tárak — FIX (OOM): `countDocuments` (NEM a doc-ok memóriába töltése; a 126k-vektoros load OOM-ozott).
         for (const registryEntry of embedding_1.FAM_STORE_REGISTRY) {
-            const dataService = new embedding_1.FAM_Entry_DataService({ dataParams: registryEntry.dataParams, issuer: this.issuer });
-            const entries = await dataService.findHydratableList({});
-            collections.push({ collection: this.realCollectionName(registryEntry.dataParams.dataName), activeDocs: entries.length });
+            const activeDocs = await this.entryCollection(registryEntry).countDocuments({});
+            collections.push({ collection: this.realCollectionName(registryEntry.dataParams.dataName), activeDocs: activeDocs });
         }
         // Helper collection-ök (reference / scope / ingest-run / config) — a DS-példányosítás regisztrálja a modellt.
         const reference_DS = new scope_reference_1.FAM_Reference_DataService({ issuer: this.issuer });
@@ -865,21 +1054,24 @@ class FAM_CapabilityRegistry_Service {
         const tables = table ? [table] : MAIN_TABLES;
         const result = [];
         for (const target of tables) {
-            const entries = await this.loadTableEntries(target);
-            const kindCounts = new Map();
-            const tagCounts = new Map();
-            for (const entry of entries) {
-                if (entry.kind) {
-                    kindCounts.set(entry.kind, (kindCounts.get(entry.kind) ?? 0) + 1);
-                }
-                for (const tag of entry.tags ?? []) {
-                    tagCounts.set(tag, (tagCounts.get(tag) ?? 0) + 1);
-                }
+            const registryEntry = embedding_1.FAM_STORE_REGISTRY.find((entry) => entry.table === target);
+            if (!registryEntry) {
+                continue;
             }
+            // FIX (OOM): Mongo-aggregáció ($group kind / $unwind+$group tag) — NEM tölti a doc-okat memóriába.
+            const collection = this.entryCollection(registryEntry);
+            const kindAgg = await collection
+                .aggregate([
+                { $match: { kind: { $ne: null } } }, { $group: { _id: '$kind', n: { $sum: 1 } } }, { $sort: { n: -1 } },
+            ]).toArray();
+            const tagAgg = await collection
+                .aggregate([
+                { $unwind: '$tags' }, { $group: { _id: '$tags', n: { $sum: 1 } } }, { $sort: { n: -1 } },
+            ]).toArray();
             result.push({
                 table: target,
-                kinds: this.sortedCounts(kindCounts).map((entry) => ({ kind: entry.label, count: entry.count })),
-                tags: this.sortedCounts(tagCounts).map((entry) => ({ tag: entry.label, count: entry.count })),
+                kinds: kindAgg.filter((group) => group._id).map((group) => ({ kind: group._id, count: group.n })),
+                tags: tagAgg.filter((group) => group._id).map((group) => ({ tag: group._id, count: group.n })),
             });
         }
         return result;
@@ -890,8 +1082,17 @@ class FAM_CapabilityRegistry_Service {
         const tables = table ? [table] : MAIN_TABLES;
         const collected = [];
         for (const target of tables) {
-            const entries = await this.loadTableEntries(target);
-            for (const entry of entries) {
+            const registryEntry = embedding_1.FAM_STORE_REGISTRY.find((entry) => entry.table === target);
+            if (!registryEntry) {
+                continue;
+            }
+            // FIX (OOM): per-tár BOUNDED query (`sort __created` + `limit`), NEM a teljes tár betöltése N elemért.
+            const docs = await this.entryCollection(registryEntry)
+                .find({}, { projection: { kind: 1, tags: 1, __created: 1, content: 1 } })
+                .sort({ __created: -1 })
+                .limit(cappedLimit)
+                .toArray();
+            for (const entry of docs) {
                 if (!entry._id) {
                     continue;
                 }
@@ -949,7 +1150,8 @@ class FAM_CapabilityRegistry_Service {
                     .map((ref) => ref.scopeId)
                     .filter((scopeId) => scopeId && !activeScopeIds.has(scopeId));
                 if (missing.length && entry._id) {
-                    brokenLinks.push({ id: entry._id, table: target, missingScopeIds: missing });
+                    // String-koerció: a nyers Mongo-driver `_id`-je ObjectId (típus-konzisztencia a riportban).
+                    brokenLinks.push({ id: String(entry._id), table: target, missingScopeIds: missing });
                 }
             }
         }
@@ -960,7 +1162,8 @@ class FAM_CapabilityRegistry_Service {
      * (legrégebbi `__created`) + a beolvasztható jelöltek. NEM ír — csak riportál (mit VONNA ÖSSZE). A
      * tényleges összevonás (soft-delete) BACKLOG.
      */
-    async deduplicateEntriesDryRun(table) {
+    async deduplicateEntriesDryRun(table, maxGroups) {
+        const groupCap = maxGroups ?? 500;
         const tables = table ? [table] : MAIN_TABLES;
         let scannedEntries = 0;
         const duplicateGroups = [];
@@ -980,14 +1183,26 @@ class FAM_CapabilityRegistry_Service {
                 if (group.length < 2) {
                     continue;
                 }
-                // A megtartandó = a legrégebbi (`__created` ASC); a többi a merge-jelölt.
+                // A megtartandó = a legrégebbi (`__created` ASC); a többi a merge-jelölt. KRITIKUS: a nyers
+                // Mongo-driver `_id`-je ObjectId (NEM string) — String-koerció nélkül a `.length`-szűrő MINDEN
+                // merge-jelöltet kidobott (üres `mergeIds` — 2026-07-15 bugfix).
                 const sorted = group.slice().sort((a, b) => this.createdMs(a) - this.createdMs(b));
-                const keepId = sorted[0]._id ?? '';
-                const mergeIds = sorted.slice(1).map((entry) => entry._id ?? '').filter((id) => id.length > 0);
+                const keepId = String(sorted[0]._id ?? '');
+                const mergeIds = sorted.slice(1).map((entry) => String(entry._id ?? '')).filter((id) => id.length > 0);
                 duplicateGroups.push({ table: target, contentHash: contentHash, keepId: keepId, mergeIds: mergeIds });
             }
         }
-        return { dryRun: true, scannedEntries: scannedEntries, duplicateGroups: duplicateGroups };
+        // A LEGNAGYOBB csoportok elöl + output-cap (a full-tár audit 50k+ csoportot adhat — a riport a top-N-re
+        // fókuszál, a `totalGroups`/`truncated` jelzi a teljes terjedelmet; nincs néma csonkolás).
+        duplicateGroups.sort((left, right) => right.mergeIds.length - left.mergeIds.length);
+        const totalGroups = duplicateGroups.length;
+        return {
+            dryRun: true,
+            scannedEntries: scannedEntries,
+            totalGroups: totalGroups,
+            truncated: totalGroups > groupCap,
+            duplicateGroups: duplicateGroups.slice(0, groupCap),
+        };
     }
     // =========================================================================
     // MP-12 debug: explain-search / inspect-chunk / inspect-embedding
@@ -1083,14 +1298,22 @@ class FAM_CapabilityRegistry_Service {
     // =========================================================================
     // MP-12 közös entry-helperek (lazy DataService — eager-resolve elkerülés)
     // =========================================================================
-    /** Egy fő tár aktív entry-i (a per-tár dataParams-szal). Nem-fő/ismeretlen tár → üres. */
+    /**
+     * Egy fő tár aktív entry-i (a per-tár dataParams-szal). Nem-fő/ismeretlen tár → üres.
+     * FIX (OOM): a nagy `contentVector` (2560 float/doc) PROJEKCIÓVAL KIHAGYVA — a fogyasztók (kinds/recent/repair/
+     * dedup) NEM használják; e nélkül a teljes-tár betöltés ~20×-kal kisebb (a 126k vektor a heap-OOM forrása volt).
+     */
     async loadTableEntries(table) {
         const registryEntry = embedding_1.FAM_STORE_REGISTRY.find((entry) => entry.table === table);
         if (!registryEntry) {
             return [];
         }
-        const dataService = new embedding_1.FAM_Entry_DataService({ dataParams: registryEntry.dataParams, issuer: this.issuer });
-        return dataService.findHydratableList({});
+        return this.entryCollection(registryEntry).find({}, { projection: { contentVector: 0 } }).toArray();
+    }
+    /** Egy fő RAG-tár mongoose-collection-je (a DS-példányosítás regisztrálja a modellt; onnan a valós collection). */
+    entryCollection(registryEntry) {
+        new embedding_1.FAM_Entry_DataService({ dataParams: registryEntry.dataParams, issuer: this.issuer });
+        return mongoose_1.default.models[registryEntry.dataParams.dataName].collection;
     }
     /** Egy entry feloldása `id`-ből (a megadott tárból, vagy minden fő tárból). Nincs → `FAM-MCP-DISPATCH-002`. */
     async requireEntryById(id, table, capability) {
@@ -1110,7 +1333,7 @@ class FAM_CapabilityRegistry_Service {
             }
             const dataService = new embedding_1.FAM_Entry_DataService({ dataParams: registryEntry.dataParams, issuer: this.issuer });
             const entry = await dataService.findData({ _id: id }, true);
-            if (entry && entry._id) {
+            if (entry?._id) {
                 return entry;
             }
         }
@@ -1190,7 +1413,7 @@ class FAM_CapabilityRegistry_Service {
     scopeLayerArraySchema() {
         return {
             type: 'array',
-            description: 'Nyers scope-lánc (root→leaf): [{ layer, rawName }] párok.',
+            description: 'Nyers scope-lánc (root→leaf): [{ layer: layer, rawName: rawName }] párok.',
             items: this.objectSchema({
                 layer: { type: 'string', description: 'A dinamikus layer-név (pl. organization/project).' },
                 rawName: { type: 'string', description: 'A nyers (feloldatlan) scope-név.' },

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

@@ -7,6 +7,7 @@ const fsm_dynamo_1 = require("@futdevpro/fsm-dynamo");
 const fam_table_type_enum_1 = require("../../../_enums/fam-table.type-enum");
 const error_codes_const_1 = require("../../../_collections/error-codes.const");
 const fam_error_factory_util_1 = require("../../../_collections/fam-error-factory.util");
+const config_control_service_1 = require("../../../_routes/server/config/config.control-service");
 const retrieval_1 = require("../../retrieval");
 /**
  * `FAM_ReadTool_Service` (SP-6.2, dsgn-003 §2) — a `read` core-tool **transport-agnosztikus**
@@ -41,9 +42,78 @@ class FAM_ReadTool_Service {
         const request = this.toRetrievalRequest(input);
         const response = await retrieval_1.FAM_Retrieval_ControlService.getInstance().read(request);
         this.rebaseToBasePath(response, input.basePath);
+        // Token-budget ÉRVÉNYESÍTÉS (FAM-REV 2026-06-22): a read-válasz INLINE marad (különben a nagy találat-tartalom
+        // miatt a MCP-host FÁJLBA menti → extra olvasás-lépés). A `read.maxTokens` (default 4000) felett a hit-tartalom
+        // levágódik + a túlcsorduló hit-ek elhagyva, `truncated:true`-val. A FAM mindig DIREKT adja vissza a találatokat.
+        FAM_ReadTool_Service.applyTokenBudget(response, await FAM_ReadTool_Service.resolveMaxTokens());
         this.logReadActivity(input, response);
         return response;
     }
+    /** A `read.maxTokens` config feloldása (default/fallback 4000, min 256). */
+    static async resolveMaxTokens() {
+        try {
+            const resolved = await config_control_service_1.FAM_Config_ControlService.getInstance().resolve('read.maxTokens', {});
+            const value = typeof resolved.value === 'number' ? resolved.value : Number(resolved.value);
+            return Number.isFinite(value) && value >= 256 ? Math.floor(value) : 4000;
+        }
+        catch {
+            return 4000;
+        }
+    }
+    /**
+     * A read-válasz token-budgetre vágása (pure; ~4 char/token). A hit-eket sorrendben tartja meg; a budget elérésekor
+     * az aktuális hit `content`-jét a maradékra vágja (`…[levágva]`), a többi hitet elhagyja, és a query-eredményt
+     * `truncated:true`-ra állítja. Üres/`includeContent:false` válasz → no-op. Így a read INLINE marad (nem fájl).
+     *
+     * **ROUND-ROBIN allokáció (eval-lelet 2026-06-25 — multi-query starvation fix):** a budget KÖZÖS az egész válaszra,
+     * de NEM query-sorban fogy (különben az ELSŐ query elfogyasztaná, és a többi query 0 hitet kapna — silent data-loss
+     * a multi-query read-en). Helyette KÖRÖNKÉNT haladunk: minden körben MINDEN query EGY következő hitje kerül sorra
+     * (#1-ek, majd #2-k, …), így minden query megkapja a TOP-hitjeit, mielőtt a budget elfogy → egy query SEM éhezik.
+     */
+    static applyTokenBudget(response, maxTokens) {
+        const charBudget = Math.max(256, maxTokens) * 4;
+        const metaPerHit = 220; // a per-hit metaadat (score/path/heading/…) durva char-költsége
+        const results = response.results ?? [];
+        if (!results.length) {
+            return;
+        }
+        const kept = results.map(() => []);
+        const maxHits = Math.max(0, ...results.map((result) => (result.hits ?? []).length));
+        let used = 0;
+        let budgetExhausted = false;
+        for (let round = 0; round < maxHits && !budgetExhausted; round++) {
+            for (let ri = 0; ri < results.length && !budgetExhausted; ri++) {
+                const hit = (results[ri].hits ?? [])[round];
+                if (!hit) {
+                    continue;
+                }
+                if (used + metaPerHit >= charBudget) {
+                    budgetExhausted = true;
+                    break;
+                }
+                used += metaPerHit;
+                if (typeof hit.content === 'string' && hit.content.length > 0) {
+                    const remaining = charBudget - used;
+                    if (hit.content.length > remaining) {
+                        hit.content = `${hit.content.slice(0, Math.max(0, remaining - 12))}…[levágva]`;
+                        used = charBudget;
+                        kept[ri].push(hit);
+                        budgetExhausted = true;
+                        break;
+                    }
+                    used += hit.content.length;
+                }
+                kept[ri].push(hit);
+            }
+        }
+        // A megtartott hitek visszaírása + `truncated:true` ott, ahol elhagytunk hitet (a teljes halmaznál kevesebb maradt).
+        for (let ri = 0; ri < results.length; ri++) {
+            if ((results[ri].hits ?? []).length > kept[ri].length) {
+                results[ri].truncated = true;
+            }
+            results[ri].hits = kept[ri];
+        }
+    }
     /**
      * Ha a kérés `basePath`-et ad, a hit-ek `sourceFilePath`-ját a KANONIKUS `absolutePath`-ból a `basePath`-hez
      * RELATÍVAN írjuk át (a hívó saját workspace-kontextusa — FAM-REV-050), `/`-normalizálva. `absolutePath` nélküli
@@ -98,7 +168,7 @@ class FAM_ReadTool_Service {
             throw fam_error_factory_util_1.FAM_Error_Util.create({
                 errorCode: error_codes_const_1.FAM_ERROR_CODES.valReadEmptyOrReference,
                 message: 'A `read` legalább egy query-t igényel (`queries[]`). Adj meg legalább egy '
-                    + '{ tables, query } blokkot.',
+                    + '{ tables: tables, query: query } blokkot.',
                 issuer: this.issuer,
                 context: { operation: 'read-validate' },
             });

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

@@ -6,6 +6,7 @@ const error_codes_const_1 = require("../../../_collections/error-codes.const");
 const fam_error_factory_util_1 = require("../../../_collections/fam-error-factory.util");
 const fam_entry_data_model_1 = require("../../../_models/data-models/fam-entry.data-model");
 const embedding_1 = require("../../embedding");
+const config_control_service_1 = require("../../../_routes/server/config/config.control-service");
 const ingest_1 = require("../../ingest");
 const migration_1 = require("../../migration");
 const scope_reference_1 = require("../../scope-reference");
@@ -178,11 +179,44 @@ class FAM_WriteTool_Service {
         const warnings = embedOutcome.status === 'error'
             ? ['Az entry mentve, de az embedding sikertelen (érdemes ellenőrizni az embedding-providert; `re-embed`).']
             : [];
+        // NEAR-DUPLIKÁTUM-WARNING (user-FR 2026-06-25): a friss vektorral megnézzük, van-e a tárban „majdnem azonos"
+        // meglévő entry (koszinusz ≥ küszöb). Ha igen → jelzés (NEM blokkol) → az agent tudja: érdemes lehet a meglévőt
+        // UPDATE-elni, nem új entry-t létrehozni. A vektor már kész (nincs extra embed); a check 1 vektor-keresés.
+        if (embedOutcome.status === 'completed' && embedOutcome.vector.length) {
+            await this.appendDedupWarning(input.table, embedOutcome.vector, createdId, warnings);
+        }
         return this.baseOutput({
             operation: input.operation, table: input.table, scopePath: resolve.scopePath,
             uncertaintyNotes: resolve.uncertaintyNotes, created: createdId ? [createdId] : [], warnings: warnings,
         });
     }
+    /**
+     * Near-duplikátum-warning hozzáfűzése (user-FR 2026-06-25): a `write.dedupWarnEnabled`/`write.dedupWarnThreshold`
+     * config alapján a friss vektor legközelebbi szomszédait nézi; a küszöb fölötti meglévő entry(ke)t jelzi. Best-effort:
+     * a hiba NEM buktatja a write-ot (a jelzés kényelmi, nem kritikus).
+     */
+    async appendDedupWarning(table, vector, createdId, warnings) {
+        try {
+            const config = config_control_service_1.FAM_Config_ControlService.getInstance();
+            const enabledVal = (await config.resolve('write.dedupWarnEnabled', { table: table })).value;
+            if (enabledVal === false) {
+                return;
+            }
+            const thVal = (await config.resolve('write.dedupWarnThreshold', { table: table })).value;
+            const threshold = typeof thVal === 'number' ? thVal : 0.93;
+            const nearDups = await embedding_1.FAM_DedupWarn_ControlService.getInstance().check({
+                table: table, vector: vector, excludeId: createdId, threshold: threshold,
+            });
+            if (nearDups.length) {
+                const list = nearDups.map((dup) => `${dup.id} (${dup.score.toFixed(3)})`).join(', ');
+                warnings.push(`⚠ Near-duplikátum: az új tartalom nagyon hasonló a meglévő ${list} bejegyzés(ek)hez `
+                    + `(koszinusz ≥ ${threshold}). Fontold meg a MEGLÉVŐ frissítését (update) új entry létrehozása helyett.`);
+            }
+        }
+        catch {
+            // best-effort — a dedup-warning kényelmi, a hiba nem buktatja a write-ot.
+        }
+    }
     /**
      * `update` (dsgn-003 §3.1) → MP-1 modify + (ha content változott) MP-2 re-embed. A `target`
      * kötelező (`id`/`sourceFilePath`/`query`). A scope opcionális update-nél (a meglévő entry scope-ja
@@ -277,6 +311,8 @@ class FAM_WriteTool_Service {
             include: scan.include,
             exclude: scan.exclude,
             dryRun: scan.dryRun,
+            preserveHistory: scan.preserveHistory,
+            tableOverride: scan.tableOverride,
             weights: scan.weights,
             issuer: this.issuer,
         };

package/build/src/_modules/migration/_services/fam-claude-mem-import.control-service.js

@@ -417,7 +417,7 @@ class FAM_ClaudeMemImport_ControlService {
         }
         const overrideKey = `project:${record.project}`;
         const override = request.overrides?.scope?.[overrideKey];
-        if (override && override.scopePath.length) {
+        if (override?.scopePath.length) {
             return override.scopePath.map((layer) => ({ layer: layer.layer, rawName: layer.rawName }));
         }
         return [{ layer: PROJECT_SCOPE_LAYER, rawName: record.project }];