@futdevpro/fdp-agent-memory 1.1.14 → 1.1.30

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

@@ -14,8 +14,11 @@ const fam_entry_data_model_1 = require("../../../_models/data-models/fam-entry.d
 const fam_reference_code_util_1 = require("../../../_collections/fam-reference-code.util");
 const embedding_1 = require("../../embedding");
 const scope_reference_1 = require("../../scope-reference");
+const fam_cooldown_util_1 = require("../../../_collections/fam-cooldown.util");
 const fam_content_hash_util_1 = require("../_collections/fam-content-hash.util");
 const fam_git_repo_util_1 = require("../_collections/fam-git-repo.util");
+const fam_scan_reconcile_util_1 = require("../_collections/fam-scan-reconcile.util");
+const fam_secret_content_util_1 = require("../_collections/fam-secret-content.util");
 const fam_project_identity_util_1 = require("../_collections/fam-project-identity.util");
 const fam_scan_path_util_1 = require("../_collections/fam-scan-path.util");
 const fam_scan_progress_util_1 = require("../_collections/fam-scan-progress.util");
@@ -186,6 +189,11 @@ class FAM_Ingest_ControlService {
         // Futás-közbeni progress (descriptive user feedback): a NAGY (workspace-szintű) scan haladását
         // throttle-olt `[famIngest]` sorokkal jelezzük a konzolon (a `dryRun` NEM embeddel → ott nincs progress).
         const progressIntervalMs = await this.resolveScanNumber('scan.progressIntervalMs', canonicalScope, 2000);
+        // Kikapcsolható szekció-cooldown (user-FR): a NAGY scan ne terhelje túl a gépet — a batch-ek KÖZÉ
+        // opcionális szünet (default 0 = ki; dryRun-on sosem várunk, mert ott nincs valódi embed-munka).
+        const sectionCooldownMs = isDryRun
+            ? 0
+            : fam_cooldown_util_1.FAM_Cooldown_Util.resolveMs((await config_control_service_1.FAM_Config_ControlService.getInstance().resolve('scan.sectionCooldownMs', { scopePath: canonicalScope })).value);
         let lastProgressAt = startedAt;
         for (let i = 0; i < total; i += flowLimit) {
             const batch = discovery.routedFiles.slice(i, i + flowLimit);
@@ -212,13 +220,19 @@ class FAM_Ingest_ControlService {
                     verdicts: verdicts, elapsedSeconds: (now - startedAt) / 1000,
                 }));
             }
+            // Szekció-cooldown: a batch-ek KÖZÉ (NEM az utolsó után) — opcionális gép-tehermentesítő szünet.
+            if (sectionCooldownMs > 0 && processed < total) {
+                await fam_cooldown_util_1.FAM_Cooldown_Util.sleep(sectionCooldownMs);
+            }
         }
         // (4b) Törölt-fájl reconciliation (whole-file orphan) — CSAK folder/project scan (a `scan-file`
         // egyetlen fájlt céloz, nem reconciliál). A lemezről eltűnt fájlok chunkjai soft-delete-elődnek; a
         // számuk a `verdicts.deleted`-be (a per-fájl, fájlon-belüli `deleted`-ek mellé).
         if (request.operation !== 'scan-file') {
+            const reconcileIgnored = await this.resolveReconcileIgnored(canonicalScope);
             verdicts.deleted += await this.reconcileDeletedFiles({
                 discovery: discovery, scopePath: canonicalScope, issuer: issuer, dryRun: request.dryRun ?? false,
+                reconcileIgnored: reconcileIgnored,
             });
         }
         // (4c) File-rendszer összefoglaló (knowledge) — generált „mi van a projektben" entry a mappastruktúrából
@@ -272,7 +286,15 @@ class FAM_Ingest_ControlService {
     async processFile(set) {
         const table = set.file.route;
         try {
-            const content = fs.readFileSync(set.file.absolutePath, 'utf-8');
+            const rawContent = fs.readFileSync(set.file.absolutePath, 'utf-8');
+            // Tartalmi secret-redakció (user-FR): a forrásba hardcode-olt API-kulcs (sk-/AKIA/ghp_/PEM/JWT) a tárolt
+            // szöveg/embedding ELŐTT redaktálódik → a titok sose kerül a DB-be (a contentHash is a redaktáltból → egy
+            // korábban-szivárgott fájl RE-SCANKOR `modified` → auto-gyógyul). A redaktálatlan kód-kontextus megmarad.
+            const redaction = fam_secret_content_util_1.FAM_SecretContent_Util.redact(rawContent);
+            if (redaction.count > 0) {
+                fsm_dynamo_1.DyFM_Log.warn(`[famIngest] secret-redakció: ${redaction.count} token redaktálva (${set.file.relativePath})`);
+            }
+            const content = redaction.text;
             // FAM-REV-064 bináris-tartalom guard: a denylist-en átcsúszott, ismeretlen-kiterjesztésű bináris
             // (null-byte az első ~8KB-ban) NE kerüljön a generic chunkerbe (szemét-chunk ellen). Skip → 0 chunk.
             if (FAM_Ingest_ControlService.isLikelyBinary(content)) {
@@ -351,6 +373,10 @@ class FAM_Ingest_ControlService {
                             // re-embed nélkül (a friss chunk charStart/charEnd/sor-pozíciója felülír, ha eltér).
                             await set.dataService.backfillPosition(item.existingId, item.chunk.position);
                         }
+                        // Git-provenance backfill (user-FR 2026-06-22): a CSAK-metaadat frissítés — a git-provenance
+                        // feature ELŐTT ingestelt korpusz `equal`-chunkjai is megkapják a repoUrl/repoRelativePath/
+                        // repoBranch-et RE-EMBED NÉLKÜL (a control-service számolja, így nincs data-service↔ingest ciklus).
+                        await set.dataService.backfillGitProvenance(item.existingId, fam_git_repo_util_1.FAM_GitRepo_Util.sourceFieldsFor(set.file.absolutePath));
                     }
                     catch {
                         // best-effort metaadat-frissítés — a content már naprakész (equal), nem eszkaláljuk.
@@ -457,7 +483,7 @@ class FAM_Ingest_ControlService {
         const existing = await dataService.findHydratableList(filter);
         const existingEntry = existing[0];
         // Változatlan fájl-lista → NO-OP (nincs fölös re-embed).
-        if (existingEntry && existingEntry.contentHash === contentHash) {
+        if (existingEntry?.contentHash === contentHash) {
             return;
         }
         const entry = new fam_entry_data_model_1.FAM_Entry({
@@ -594,15 +620,15 @@ class FAM_Ingest_ControlService {
      * így egy al-mappa scan a tágabb gyökérről ingestelt, de a saját subtree-jébe eső fájlokat is helyesen
      * reconciliálja (és kívülre sosem nyúl). Az `absolutePath` nélküli (régi, migrálatlan) entry-ket kihagyja
      * (no-migration safe). `dryRun` → csak számol. Visszaadja a reconciliált (soft-deleted) chunkok számát.
+     *
+     * **`reconcileIgnored` (user-FR 2026-06-21, default true):** a most ignore-mintával (hard/config/`.fdpfamignore`)
+     * kizárttá vált, de KORÁBBAN beolvasott fájlok is orphanná válnak → a régi chunkjaik kitakarítódnak (ne ragadjon
+     * be, amit ignore-olni akarunk). A present-set számítása a `FAM_ScanReconcile_Util.computePresentPaths`-ban (pure).
      */
     async reconcileDeletedFiles(set) {
-        const presentPaths = new Set();
-        for (const routed of set.discovery.routedFiles) {
-            presentPaths.add(routed.absolutePath);
-        }
-        for (const skipped of set.discovery.skippedFiles) {
-            presentPaths.add(skipped.absolutePath);
-        }
+        // A present-set (lemezen megtalált fájlok). `reconcileIgnored` → a MOST ignore-mintával kizárt fájl NEM present
+        // (a régi chunkja orphan → kitakarítható); a többi skip (secret/méret/unrouted) present marad (FAM_ScanReconcile_Util).
+        const presentPaths = fam_scan_reconcile_util_1.FAM_ScanReconcile_Util.computePresentPaths(set.discovery.routedFiles, set.discovery.skippedFiles, set.reconcileIgnored);
         const leafScopeId = set.scopePath.length ? set.scopePath[set.scopePath.length - 1].scopeId : undefined;
         let reconciled = 0;
         for (const table of set.discovery.tables) {
@@ -651,6 +677,11 @@ class FAM_Ingest_ControlService {
         const value = typeof resolved.value === 'number' ? resolved.value : 20;
         return Math.min(Math.max(value, 1), 200);
     }
+    /** Az ignore-add reconciliation (most-kizárt fájlok kitakarítása) a config-ból (`scan.reconcileIgnored`, default true). */
+    async resolveReconcileIgnored(scopePath) {
+        const resolved = await config_control_service_1.FAM_Config_ControlService.getInstance().resolve('scan.reconcileIgnored', { scopePath: scopePath });
+        return typeof resolved.value === 'boolean' ? resolved.value : true;
+    }
     /** Egy scan-szám-config feloldása a scope-kontextussal + fallback-kel (a `scan.estimateMsPerChunk` / `scan.progressIntervalMs`-hez). */
     async resolveScanNumber(key, scopePath, fallback) {
         const resolved = await config_control_service_1.FAM_Config_ControlService.getInstance().resolve(key, { scopePath: scopePath });

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

@@ -51,16 +51,35 @@ class FAM_Scan_ControlService {
         if (famIgnore.length) {
             fsm_dynamo_1.DyFM_Log.info(`[famIngest] .fdpfamignore betöltve (${resolvedRoot}): ${famIgnore.length / 2} minta-sor`);
         }
-        const ignorePatterns = [...baseIgnore, ...famIgnore];
+        // KÉT külön ignore-réteg: a `hardIgnore` (config-default `node_modules`/`.git`/`build`/`dist`/… + config +
+        // input-exclude) — ezt a `!`-re-include SOHA nem éleszti fel (különben a `!client/` a `client/node_modules`-t
+        // is visszahozná → katasztrofális walk). A `softIgnore` (a .fdpfamignore `*`/saját mintái) — EZT írhatja felül
+        // a negáció. Így a „minden-kivéve-X" a hard-defaultokat tiszteletben tartja (eleve-tisztán-szkennelés).
+        const hardIgnore = baseIgnore;
+        const softIgnore = famIgnore;
+        // Re-include (`!`) szabályok a .fdpfamignore-ból (negáció — user-FR): a fájl-szintű re-include-match (`globs`)
+        // + a könyvtár-prune lineage-bázisok (`bases`). Üres a scan-file-nál / ha nincs negáció.
+        const reinclude = set.operation === 'scan-file'
+            ? { globs: [], bases: [] }
+            : fam_famignore_util_1.FAM_FamIgnore_Util.loadReincludeRules(resolvedRoot);
         const maxFileSizeBytes = await this.resolveMaxFileSize(set.scopePath);
         const followSymlinks = await this.resolveFollowSymlinks(set.scopePath);
         const testFileWeight = await this.resolveTestFileWeight(set.scopePath);
+        // NESTED `.fdpfamignore` (config-kapcsolós, default ON): a bejárás közben minden al-mappa saját famignore-ja
+        // is érvényesül (a saját al-útjához horgonyozva). A `collected` a walk-közben FELFEDEZETT nested-mintákat
+        // gyűjti, hogy a MÁSODIK (classify) kör is lássa őket (a minták al-út-horgonyzottak → globálisan egyértelműek).
+        const nestedEnabled = set.operation === 'scan-file' ? false : await this.resolveNestedFamignore(set.scopePath);
+        const collected = { soft: [], reGlobs: [], reBases: [] };
         const routedFiles = [];
         const skippedFiles = [];
         // A felderített abszolút fájlok (file = 1 db; folder/project = rekurzív bejárás).
         const absoluteFiles = set.operation === 'scan-file'
             ? [resolvedRoot]
-            : this.walkDirectory(resolvedRoot, resolvedRoot, ignorePatterns, followSymlinks);
+            : this.walkDirectory(resolvedRoot, resolvedRoot, hardIgnore, softIgnore, reinclude, followSymlinks, { enabled: nestedEnabled, collected: collected });
+        // A classify-kör effektív soft-ignore + re-include halmaza: a gyökér-szintű + MINDEN walk-közben felfedezett
+        // nested minta (a nested fájl-szintű skip-ekhez — a dir-prune-t a walk már elvégezte). Üres collector → no-op.
+        const classifySoft = collected.soft.length ? [...softIgnore, ...collected.soft] : softIgnore;
+        const classifyReGlobs = collected.reGlobs.length ? [...reinclude.globs, ...collected.reGlobs] : reinclude.globs;
         for (const absolutePath of absoluteFiles) {
             const relativePath = set.operation === 'scan-file'
                 ? path.basename(resolvedRoot)
@@ -68,7 +87,9 @@ class FAM_Scan_ControlService {
             const routed = this.classifyFile({
                 absolutePath: absolutePath,
                 relativePath: relativePath,
-                ignorePatterns: ignorePatterns,
+                hardIgnorePatterns: hardIgnore,
+                softIgnorePatterns: classifySoft,
+                reincludePatterns: classifyReGlobs,
                 includePatterns: set.include,
                 maxFileSizeBytes: maxFileSizeBytes,
                 tableOverride: set.tableOverride,
@@ -103,9 +124,16 @@ class FAM_Scan_ControlService {
         if (fam_secret_exclude_util_1.FAM_SecretExclude_Util.isSecret(set.relativePath)) {
             return { ...base, route: 'skip', skipReason: 'secret-exclude (filename/path-based; content-PII scan = BACKLOG)' };
         }
-        // (2) Ignore-patterns (dsgn-004 §6.2) — node_modules/.git/build/dist/lock/... + a config + input-exclude.
-        if (fam_glob_match_util_1.FAM_GlobMatch_Util.matchesAny(set.relativePath, set.ignorePatterns)) {
-            return { ...base, route: 'skip', skipReason: 'ignore-pattern' };
+        // (2a) HARD ignore (dsgn-004 §6.2) — node_modules/.git/build/dist/lock/… + a config + input-exclude.
+        // Ezt a `!`-re-include SOHA nem éleszti fel (a `!client/` ne hozza vissza a `client/node_modules`-t).
+        if (fam_glob_match_util_1.FAM_GlobMatch_Util.matchesAny(set.relativePath, set.hardIgnorePatterns)) {
+            return { ...base, route: 'skip', skipReason: 'ignore-pattern', excludedByIgnore: true };
+        }
+        // (2b) SOFT ignore (.fdpfamignore saját mintái) — EZT a `!`-RE-INCLUDE felülírja: soft-ignore-match SKIP,
+        // KIVÉVE ha re-include-match (negáció). Így a „minden-kivéve-X" csak a famignore-szintet vonja vissza.
+        if (set.softIgnorePatterns && fam_glob_match_util_1.FAM_GlobMatch_Util.matchesAny(set.relativePath, set.softIgnorePatterns)
+            && !(set.reincludePatterns && fam_glob_match_util_1.FAM_GlobMatch_Util.matchesAny(set.relativePath, set.reincludePatterns))) {
+            return { ...base, route: 'skip', skipReason: 'ignore-pattern (famignore)', excludedByIgnore: true };
         }
         // (3) Include-szűrés (ha megadva: csak az illeszkedő fájl megy tovább, dsgn-003 §3.1).
         if (set.includePatterns && set.includePatterns.length && !fam_glob_match_util_1.FAM_GlobMatch_Util.matchesAny(set.relativePath, set.includePatterns)) {
@@ -133,8 +161,13 @@ class FAM_Scan_ControlService {
      * KÖNYVTÁRAKAT bejárás KÖZBEN kihagyja (ne lépjen `node_modules`-ba — teljesítmény + biztonság).
      * A symlinkeket alapból NEM követi (`followSymlinks` config); a path-traversal guardot minden
      * fájlra futtatja (a feloldott valódi útvonal a gyökér alatt kell maradjon).
+     *
+     * **NESTED `.fdpfamignore` (`nested.enabled`):** minden NEM-gyökér mappánál betölti a mappa saját famignore-ját
+     * (a mappa al-útjához horgonyozva), MERGE-eli az örökölt soft-ignore/re-include-ba (a leszármazottak öröklik), és
+     * a `nested.collected`-be is gyűjti (a discover második, classify-köre fájl-szinten is alkalmazza). A gyökér
+     * famignore-ját a hívó (`discover`) tölti — itt csak az al-mappákét.
      */
-    walkDirectory(currentDir, resolvedRoot, ignorePatterns, followSymlinks) {
+    walkDirectory(currentDir, resolvedRoot, hardIgnore, softIgnore, reinclude, followSymlinks, nested) {
         const result = [];
         let entries;
         try {
@@ -144,6 +177,24 @@ class FAM_Scan_ControlService {
             // Olvashatatlan könyvtár → kihagyjuk (a per-fájl olvasás-hiba a chunk-fázisban kezelt).
             return result;
         }
+        // NESTED famignore: a NEM-gyökér mappa saját `.fdpfamignore`-ja az al-útjához horgonyozva → MERGE az örököltbe
+        // (a leszármazottak ezt öröklik) + gyűjtés a classify-körhöz. A gyökér famignore-ját már a `discover` betöltötte.
+        let effSoftIgnore = softIgnore;
+        let effReinclude = reinclude;
+        if (nested.enabled && currentDir !== resolvedRoot) {
+            const baseDir = fam_scan_path_util_1.FAM_ScanPath_Util.toRelative(resolvedRoot, currentDir);
+            const nestedIgnore = fam_famignore_util_1.FAM_FamIgnore_Util.loadFromDir(currentDir, baseDir);
+            const nestedReinc = fam_famignore_util_1.FAM_FamIgnore_Util.loadReincludeRules(currentDir, baseDir);
+            if (nestedIgnore.length) {
+                effSoftIgnore = [...softIgnore, ...nestedIgnore];
+                nested.collected.soft.push(...nestedIgnore);
+            }
+            if (nestedReinc.globs.length) {
+                effReinclude = { globs: [...reinclude.globs, ...nestedReinc.globs], bases: [...reinclude.bases, ...nestedReinc.bases] };
+                nested.collected.reGlobs.push(...nestedReinc.globs);
+                nested.collected.reBases.push(...nestedReinc.bases);
+            }
+        }
         for (const entry of entries) {
             const entryPath = path.join(currentDir, entry.name);
             const relativePath = fam_scan_path_util_1.FAM_ScanPath_Util.toRelative(resolvedRoot, entryPath);
@@ -152,16 +203,26 @@ class FAM_Scan_ControlService {
                 continue;
             }
             if (entry.isDirectory()) {
-                // Az ignore-patterns a könyvtárat bejárás közben kihagyja (ne lépjen be).
-                if (fam_glob_match_util_1.FAM_GlobMatch_Util.matchesAny(relativePath, ignorePatterns)
-                    || fam_glob_match_util_1.FAM_GlobMatch_Util.matchesAny(relativePath + '/', ignorePatterns)) {
+                // HARD ignore (node_modules/.git/build/…): a könyvtárat bejárás közben FELTÉTEL NÉLKÜL kihagyja —
+                // a `!`-re-include NEM élesztheti fel (a `!client/` ne lépjen `client/node_modules`-ba). Ez tartja a
+                // walkot eleve-tisztán (a katasztrofális node_modules-bejárás kizárva még re-included dir alatt is).
+                if (fam_glob_match_util_1.FAM_GlobMatch_Util.matchesAny(relativePath, hardIgnore)
+                    || fam_glob_match_util_1.FAM_GlobMatch_Util.matchesAny(relativePath + '/', hardIgnore)) {
+                    continue;
+                }
+                // SOFT ignore (.fdpfamignore saját mintái): a mappát kihagyja — DE re-include-tudatosan: egy soft-ignore-olt
+                // mappát NEM vágunk le, ha re-included elem van rajta/alatta/fölötte (különben a `*` + `!client/` esetén a
+                // `client` szülőjét/magát levágnánk → a re-included client soha nem érhető el).
+                const softIgnored = fam_glob_match_util_1.FAM_GlobMatch_Util.matchesAny(relativePath, effSoftIgnore)
+                    || fam_glob_match_util_1.FAM_GlobMatch_Util.matchesAny(relativePath + '/', effSoftIgnore);
+                if (softIgnored && !fam_famignore_util_1.FAM_FamIgnore_Util.dirOnReincludeLineage(relativePath, effReinclude.globs, effReinclude.bases)) {
                     continue;
                 }
                 // Path-traversal guard (a feloldott valódi útvonal a gyökér alatt kell maradjon).
                 if (!this.isInsideRootSafe(resolvedRoot, entryPath)) {
                     continue;
                 }
-                result.push(...this.walkDirectory(entryPath, resolvedRoot, ignorePatterns, followSymlinks));
+                result.push(...this.walkDirectory(entryPath, resolvedRoot, hardIgnore, effSoftIgnore, effReinclude, followSymlinks, nested));
                 continue;
             }
             if (entry.isFile()) {
@@ -225,6 +286,11 @@ class FAM_Scan_ControlService {
         const resolved = await config_control_service_1.FAM_Config_ControlService.getInstance().resolve('scan.followSymlinks', { scopePath: scopePath });
         return typeof resolved.value === 'boolean' ? resolved.value : false;
     }
+    /** A nested (per-alkönyvtár) `.fdpfamignore` figyelembevétele a config-ból (`scan.nestedFamignore`, default true). */
+    async resolveNestedFamignore(scopePath) {
+        const resolved = await config_control_service_1.FAM_Config_ControlService.getInstance().resolve('scan.nestedFamignore', { scopePath: scopePath });
+        return typeof resolved.value === 'boolean' ? resolved.value : true;
+    }
     /** A teszt-/spec-fájlok default súlya a config-ból (`scan.testFileWeight`, default 0.5 — FAM-REV-058). */
     async resolveTestFileWeight(scopePath) {
         const resolved = await config_control_service_1.FAM_Config_ControlService.getInstance().resolve('scan.testFileWeight', { scopePath: scopePath });

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

@@ -25,7 +25,7 @@ const MAIN_TABLE_ENUM = Object.values(fam_table_type_enum_1.FAM_Table).filter((t
 /** A nyers scope-lánc array-schema (`{ layer, rawName }[]`). */
 const SCOPE_LAYER_ARRAY = {
     type: 'array',
-    description: 'Nyers scope-lánc (root→leaf): [{ layer, rawName }] párok (pl. organization=FutDevPro, project=Adventor).',
+    description: 'Nyers scope-lánc (root→leaf): [{ layer: layer, rawName: rawName }] párok (pl. organization=FutDevPro, project=Adventor).',
     items: {
         type: 'object',
         properties: {

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

@@ -347,7 +347,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 +393,56 @@ 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.' },
+            }),
+            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,
+                }));
+            },
+        });
         // 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)
@@ -457,7 +507,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 +606,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 +618,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 +679,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 +811,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 +925,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 +953,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;
                 }
@@ -1083,14 +1155,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 +1190,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 +1270,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

@@ -98,7 +98,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/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 }];

package/build/src/_modules/scope-reference/_collections/fam-scope-maintenance.util.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FAM_ScopeMaintenance_Util = void 0;
+/**
+ * `FAM_ScopeMaintenance_Util` (user-FR 2026-06-22) — a **scope rename/merge** Mongo-update-specjeinek
+ * TISZTA (pure) felépítője. A scope-azonosító a denormalizált `scopePath[]`-en (minden RAG-entry) ÉS a
+ * reference `canonicalScopeRef`-jén (egyetlen objektum) szerepel; a rename/merge ezeket írja át bulk-ban.
+ *
+ * **Rename** = a `scopeId`-hez tartozó `canonicalName` átírása (a scopeId marad). **Merge** = a `from`
+ * scopeId minden előfordulása az `into` scope `{scopeId, layer, canonicalName}`-jére cserélve (majd a
+ * hívó soft-delete-eli a `from` scope-ot). A spec-építés determinisztikus + külön tesztelhető; az
+ * alkalmazás (mongoose `updateMany`) a control-service-ben.
+ */
+class FAM_ScopeMaintenance_Util {
+    /** RENAME — entry-collection (`scopePath[]`): a `scopeId`-elem `canonicalName`-jét `newName`-re. */
+    static renameEntryUpdate(scopeId, newName) {
+        return {
+            filter: { 'scopePath.scopeId': scopeId },
+            update: { $set: { 'scopePath.$[el].canonicalName': newName } },
+            arrayFilters: [{ 'el.scopeId': scopeId }],
+        };
+    }
+    /** MERGE — entry-collection (`scopePath[]`): a `fromId`-elemet az `into` ref `{scopeId,layer,canonicalName}`-jére. */
+    static mergeEntryUpdate(fromId, into) {
+        return {
+            filter: { 'scopePath.scopeId': fromId },
+            update: {
+                $set: {
+                    'scopePath.$[el].scopeId': into.scopeId,
+                    'scopePath.$[el].layer': into.layer,
+                    'scopePath.$[el].canonicalName': into.canonicalName,
+                },
+            },
+            arrayFilters: [{ 'el.scopeId': fromId }],
+        };
+    }
+    /** RENAME — reference (`canonicalScopeRef`, egyetlen objektum): a `canonicalName` átírása. */
+    static renameReferenceUpdate(scopeId, newName) {
+        return {
+            filter: { 'canonicalScopeRef.scopeId': scopeId },
+            update: { $set: { 'canonicalScopeRef.canonicalName': newName } },
+        };
+    }
+    /** MERGE — reference (`canonicalScopeRef`): a `from` ref cseréje az `into`-ra. */
+    static mergeReferenceUpdate(fromId, into) {
+        return {
+            filter: { 'canonicalScopeRef.scopeId': fromId },
+            update: {
+                $set: {
+                    'canonicalScopeRef.scopeId': into.scopeId,
+                    'canonicalScopeRef.layer': into.layer,
+                    'canonicalScopeRef.canonicalName': into.canonicalName,
+                },
+            },
+        };
+    }
+}
+exports.FAM_ScopeMaintenance_Util = FAM_ScopeMaintenance_Util;