@futdevpro/fdp-agent-memory 1.1.21 → 1.1.30

package/build/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@futdevpro/fdp-agent-memory",
-    "version": "1.1.21",
+    "version": "1.1.30",
     "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": {
@@ -55,7 +55,7 @@
     "license": "FDP",
     "dependencies": {
         "@futdevpro/fsm-dynamo": "^1.16.7",
-        "@futdevpro/nts-dynamo": "^1.15.72",
+        "@futdevpro/nts-dynamo": "^1.15.74",
         "@modelcontextprotocol/sdk": "^1.12.0",
         "axios": "~1.8.1",
         "better-sqlite3": "^12.4.1",

package/build/src/_cli/_commands/scan-projects.command.js

@@ -22,7 +22,7 @@ class FAM_ScanProjects_Util {
             .description('Több projekt SOROS scan-je (auto-felderítés --root-tal vagy explicit --config-gal; nincs '
             + 'konkurrens thrash). ⚠️ MINDEN projekt-gyökérbe előbb `.fdpfamignore` + `--dry-run` (lásd lent).')
             .option('--root <dir>', 'projekt-gyökerek auto-felderítése e mappa alatt (package.json/.git markerek)')
-            .option('--config <file.json>', 'explicit projekt-lista: [{ path, project, org?, table? }]')
+            .option('--config <file.json>', 'explicit projekt-lista JSON — elemenként `path` + `project` (+ opcionális `org`, `table`)')
             .option('--depth <n>', 'auto-felderítés max mélysége (default 3)', '3')
             .option('--org <name>', 'default organization az auto-felderítéshez', 'FutDevPro')
             .option('--table <documents|codebase>', 'default cél-tár', 'codebase')

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

@@ -87,7 +87,7 @@ exports.CONFIG_CATALOG = {
     'read.importChunkWeight': {
         type: 'number', default: 0.4, min: 0.0, max: 1.0, levels: ALL_LEVELS,
         description: 'Az import-only chunkok (`chunkType:"imports"`) read-idejű rangsor-szorzója (FAM-REV-060). '
-            + 'A szimbólum-név query-knél az import-sorok (`import { X } from "./y"`) magas cosine-t kapnak, de '
+            + 'A szimbólum-név query-knél az import-sorok (`import { X: X } from "./y"`) magas cosine-t kapnak, de '
             + 'alacsony az ÉRTÉKük (csak import, nem definíció) → e szorzóval a `finalScore = score × weight × '
             + 'importChunkWeight` a definíció-chunkok ALÁ rangsorolja őket. READ-time (nincs re-embed); a nyers '
             + 'cosine score (relevancia-jelzések) NEM változik, csak a ranking. 1 = nincs csökkentés.',
@@ -269,32 +269,9 @@ exports.CONFIG_CATALOG = {
         type: 'number', default: 20, min: 1, max: 200, integer: true, levels: GLOBAL_TABLE,
         description: 'Párhuzamos ingest flow-limit (CCAP DEFAULT_INGEST_FLOW_LIMIT=20, cap 200).',
     },
-    // --- 4.8. Memória / heap-guard (OOM-hibakezelés, fogyasztó: FAM_HeapGuard_ControlService) ---
-    'memory.guardEnabled': {
-        type: 'boolean', default: true, levels: GLOBAL_ONLY,
-        description: 'A heap-guard (OOM-hibakezelés) be/ki. `true` (default): watchdog (heap-arány + GC-hányad) + a '
-            + 'nehéz write-ek (scan/import/re-embed) load-shed-je critical nyomásnál + graceful-exit a near-limit '
-            + 'zónában (a kriptikus exit-134 helyett). `false`: csak a crash-handlerek (uncaught/unhandled) aktívak.',
-    },
-    'memory.warnRatio': {
-        type: 'number', default: 0.70, min: 0.1, max: 1.0, levels: GLOBAL_ONLY,
-        description: 'Heap-arány (used/limit), ami fölött a guard `warn` szintet jelez (log; még nincs load-shed).',
-    },
-    'memory.shedRatio': {
-        type: 'number', default: 0.82, min: 0.1, max: 1.0, levels: GLOBAL_ONLY,
-        description: 'Heap-arány, ami fölött `critical` → a nehéz write-ek (scan/import/re-embed) 503-mal elutasítva '
-            + '(a könnyű read/create/update fut tovább). A GC-hányad ≥60% is critical-t vált (mark-compact thrash-jel).',
-    },
-    'memory.exitRatio': {
-        type: 'number', default: 0.92, min: 0.1, max: 1.0, levels: GLOBAL_ONLY,
-        description: 'Heap-arány, ami fölött tartósan (GC-vel sem csökken) a guard TISZTÁN kilép (exit 137) → a `fam '
-            + 'serve` ps1 prediktíven újraindít. A kriptikus „Ineffective mark-compacts" exit-134 elkerülése. shed < exit ajánlott.',
-    },
-    'memory.pollMs': {
-        type: 'number', default: 3000, min: 500, max: 60000, integer: true, levels: GLOBAL_ONLY,
-        description: 'A heap-watchdog mintavételi időköze (ms) + a GC-hányad gördülő-ablaka. Kisebb = gyorsabb '
-            + 'reakció a hirtelen növekedésre, több CPU. 3000 = jó alapérték.',
-    },
+    // (Az OOM-hibakezelés/heap-guard configja a BEDROCK `DyNTS_global_settings.memoryGuard`-ban van — NEM FAM-config:
+    // a bedrock `DyNTS_MemoryGuard`-ot a base App auto-installálja, a FAM a thresholdokat az `overrideDynamoNTSGlobalSettings`-ben
+    // állítja. Ezért nincs FAM `memory.*` config-kulcs.)
     'patterns.defaultWeight': {
         type: 'number', default: 5, min: 0, levels: [fam_config_level_type_enum_1.FAM_ConfigLevel.table], tableOnly: fam_table_type_enum_1.FAM_Table.codingPatterns,
         description: 'A coding_patterns tár default retrieval-súlya (CCAP weight 5; csak coding_patterns).',

package/build/src/_collections/title.const.js

@@ -2,30 +2,30 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FAM_title = void 0;
 exports.FAM_title = `
-⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⣠⠤⠤⠤⠤⣄⠀⠀⠀⠀⠀⠀⢀⣀⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
-⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣶⡊⠉⠉⣉⣱⡷⠶⢢⣠⢴⣶⡝⠒⠉⢉⣭⡽⠟⢉⣀⡀⠹⢭⠒⢤⣀⣀⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
-⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⡠⠔⢚⣩⡽⠿⠊⢉⣉⡂⣀⣩⠭⢴⠟⠋⠉⠉⠉⠛⠳⢦⣬⣤⡴⠞⠛⠁⠛⠳⣾⣧⠀⠟⠀⠉⠲⢄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
-⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⡠⢚⠁⠀⠰⠋⢡⠄⠀⠞⣫⢟⡥⠒⠉⠹⣿⡀⠀⠀⢦⡀⠀⠀⠀⠈⠻⡧⡀⠀⠀⠀⠀⠈⠻⣗⡶⠶⠶⢤⡀⠱⣄⡀⠀⠀⠀⠀⠀⠀⠀⠀
-⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢮⣤⡾⠀⠀⣠⡴⠋⠀⡠⣚⠥⠒⢛⡲⠄⠀⠈⢻⡆⠀⠀⠻⣦⣀⠀⠀⠀⣿⠻⣦⣀⣴⠶⠂⠀⠘⣷⡄⠀⠀⢀⣴⡿⠈⠢⡀⠀⠀⠀⠀⠀⠀
-⠀⠀⠀⠀⠀⠀⠀⡠⠖⣉⣁⡀⠀⢀⣾⠋⠴⢿⣽⠋⠀⠞⢉⣉⣽⣳⣄⣀⠀⠋⠀⠀⠀⠈⠙⣷⡄⠀⠁⠀⠙⢤⣯⡀⠀⠀⠀⣼⡇⠀⡾⠋⠁⠀⠳⣄⠘⢆⠀⠀⠀⠀⠀
-⠀⠀⠀⠀⠀⡰⠋⠰⠛⢻⡞⢉⣠⣼⡇⢀⣴⠟⠛⠒⣴⠟⠋⠉⠀⠀⢀⣀⣀⡀⠀⠀⠀⠀⠀⣸⡇⠀⠀⠳⣄⠀⠉⢿⣄⠀⢰⣿⣧⡀⠀⣴⠶⠶⣦⡼⢧⠈⢣⠀⠀⠀⠀
-⠀⠀⠀⢀⡞⣡⣶⡄⠀⡟⣳⠿⠋⠙⡍⡽⠁⣀⣤⣤⣿⡄⠀⠀⠀⠀⡿⡉⣀⣀⣤⣤⣤⣴⠾⠥⠽⣦⣄⠀⠉⠻⢶⡼⢻⠀⠈⠇⠘⡷⡄⠘⠂⠀⢀⡍⠻⣷⣄⡇⠀⠀⠀
-⠀⠀⠀⠘⣺⠏⢸⢃⣼⠟⢁⡤⠀⣠⢟⡷⠟⢋⣉⣤⡿⠇⠀⠀⠀⢰⣣⠞⠋⠉⠉⠁⡀⠀⠀⠀⠀⠀⠙⢷⣄⠀⠀⢹⣾⠀⠀⠀⠀⢸⡇⠀⣀⡀⣾⠀⠀⠈⢻⡁⢦⠀⠀
-⠀⠀⣠⢚⣵⣄⠈⣼⡇⠀⢸⠧⢞⡵⠋⠠⠚⠉⠉⠀⠀⢀⡇⠀⣰⣟⣁⣀⠀⠀⠀⠀⠉⠒⠶⣤⣤⣀⠀⠀⠙⠀⠀⢸⡇⢰⣟⠛⢶⡋⣇⠀⠉⠻⡟⡄⠀⢀⢀⣿⠀⢧⠀
-⠀⣰⠃⢸⠁⣿⠀⠸⣧⠀⢸⢣⠋⠀⣠⣤⠶⢶⢒⣤⣔⣻⠣⢼⠟⠁⠀⠙⢷⡄⠀⠀⢀⠀⠀⠀⠈⠓⢟⢦⠀⠀⠀⢸⡇⠈⠻⣦⡀⠈⠻⣷⣄⠀⠘⣿⠀⠸⣿⣇⣀⢸⠀
-⠀⡇⠀⠀⣼⠇⠀⢀⣿⠀⣇⣇⣴⠟⠋⢠⣾⠟⠉⠀⠀⠈⠳⣼⠀⠀⠀⠀⠀⠳⠀⠀⠈⢳⣄⠀⠀⠀⢸⣼⠀⠀⠀⠈⡟⢆⠀⠈⢻⡀⠀⠈⢻⣆⠀⣻⠃⠀⠀⢹⡟⠻⡀
-⠀⢧⡆⣼⠏⠀⣾⠟⠁⢰⠃⡵⠃⢀⣴⡿⠁⠀⡀⠀⠀⠀⠀⠹⣧⡀⠰⣦⡀⠀⠀⠀⠀⠀⣻⢦⣀⣠⡾⣇⠀⠀⢀⣰⠟⠙⢷⣄⠀⠀⠀⠀⠀⣿⠀⠉⢠⠄⠀⣼⡇⠀⢧
-⢀⠞⢡⡟⠀⠀⣿⠀⢀⡏⡼⠁⣴⠟⠁⠀⠀⠀⣿⠀⣀⣀⢀⣴⠘⣷⡀⠈⢻⣦⣀⠀⢀⣾⠟⠉⠀⠀⠉⠻⣷⣄⠀⠀⠀⠀⠀⠙⢷⡄⠀⠀⠀⠉⠀⣠⡟⠀⣼⣟⠀⠀⢸
-⢸⠀⠘⣧⠀⡴⠛⠳⢸⢰⠁⢰⠏⠀⠀⠀⢀⣼⡯⠟⠋⠙⠻⣷⡀⠘⠀⠀⠀⠈⠉⠻⣿⠁⠀⠀⢰⡟⠉⠀⠈⢻⣦⠀⠀⠀⣄⠀⠀⡗⠀⢸⡇⣠⣾⠟⢀⣾⠋⠹⣷⢀⡇
-⠈⢆⠀⠹⢷⣤⣀⣠⠎⡇⠀⠸⠀⠀⢀⣴⠟⠉⠀⠀⠀⢄⠀⠹⣧⡀⠀⠀⣀⡀⠀⠀⣿⠀⠀⠀⠘⣿⡄⠀⠀⠀⢹⣦⡀⠀⢿⣄⠀⢀⣠⡿⠽⣯⡁⠀⠸⠃⠀⠀⡏⠉⠀
-⠀⢠⢷⣄⠀⠈⣉⣉⢢⢳⡀⠀⠀⠀⣾⡏⠀⠀⠠⣀⡤⢿⠀⠀⠙⠷⠶⠛⠉⠈⠀⣰⠟⠀⠀⠀⠀⠘⣷⡀⠀⠠⠛⠉⠉⠀⢈⣯⠗⠛⠁⠀⠀⠈⠃⠀⢀⣴⠇⢠⠇⠀⠀
-⠀⢸⡀⠻⣧⠈⠉⠹⣏⢀⣑⠤⣀⣀⠼⠳⣄⠀⠀⠀⠙⠺⠖⣦⣤⠤⣀⡀⠀⠀⠘⠁⠀⠀⠀⠀⠀⠀⢸⢧⡀⠀⠀⢀⣀⢴⣿⣅⡀⠠⠶⢿⢦⣀⣠⣴⠟⠃⡠⠋⠀⠀⠀
-⠀⠀⠳⡀⠘⠃⠀⡤⠸⣼⠀⠉⠛⠋⠉⠉⠙⠻⣦⣄⠀⠀⠀⠀⠈⠉⠙⠻⣦⠀⠀⠀⠀⡀⠀⠀⠀⢀⣾⠖⠚⠛⠛⠛⠋⠁⠀⠙⣷⠀⠀⣸⡴⠛⠉⢁⡤⠊⠁⠀⠀⠀⠀
-⠀⠀⠀⠘⢦⡀⠸⣧⠀⢻⢇⠀⠳⡤⣤⠆⠀⠀⠈⢻⡇⠀⠀⠀⢰⡄⠀⠀⣿⡇⢀⡾⠛⠛⠻⡝⣲⠟⠋⠀⢀⡄⠀⠀⠀⣀⡄⠀⠋⢀⡴⣻⡄⣤⡶⡍⠀⠀⠀⠀⠀⠀⠀
-⠀⠀⠀⠀⠀⠈⠙⠁⠉⠉⠈⠣⡀⠹⣇⠀⠀⠀⠀⠘⠀⠀⠀⢀⡾⢳⡶⠾⠋⠀⠈⠃⠀⠀⣠⠟⢄⣀⣠⡴⠋⠀⠀⠀⣼⢻⣤⣴⠶⠟⠋⣡⡷⣏⢿⡧⠀⠀⠀⠀⠀⠀⠀
-⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠈⠓⢫⣲⣤⣀⣀⣀⣀⣤⣶⣻⠋⠛⠷⣦⣤⣤⣄⡤⢤⣺⠕⠋⠉⠉⠁⠀⠀⣀⣤⣾⠏⢩⠀⠀⢀⣤⣾⠛⣧⢻⣼⠀⠀⠀⠀⠀⠀⠀⠀
-⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠈⠓⠮⢭⣉⣉⡩⠥⠚⠈⢇⠀⢠⡄⠀⠉⠉⠙⣿⠀⢠⠶⠖⢫⣩⠟⠛⠛⠉⠀⣠⣿⣦⠶⠿⣭⣸⣇⡿⠞⠁⠀⠀⠀⠀⠀⠀⠀⠀
-⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠈⠳⣌⡿⣄⠀⠒⠚⠋⠀⠀⠀⣠⡾⠃⠀⢀⣀⠴⠚⠉⠣⢍⣛⣶⡶⠝⠃⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
-⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠙⠒⠂⠀⠒⠒⠉⠀⠉⠉⠉⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀   
-                  
+        ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⣠⠤⠤⠤⠤⣄⠀⠀⠀⠀⠀⠀⢀⣀⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
+        ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣶⡊⠉⠉⣉⣱⡷⠶⢢⣠⢴⣶⡝⠒⠉⢉⣭⡽⠟⢉⣀⡀⠹⢭⠒⢤⣀⣀⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
+        ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⡠⠔⢚⣩⡽⠿⠊⢉⣉⡂⣀⣩⠭⢴⠟⠋⠉⠉⠉⠛⠳⢦⣬⣤⡴⠞⠛⠁⠛⠳⣾⣧⠀⠟⠀⠉⠲⢄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
+        ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⡠⢚⠁⠀⠰⠋⢡⠄⠀⠞⣫⢟⡥⠒⠉⠹⣿⡀⠀⠀⢦⡀⠀⠀⠀⠈⠻⡧⡀⠀⠀⠀⠀⠈⠻⣗⡶⠶⠶⢤⡀⠱⣄⡀⠀⠀⠀⠀⠀⠀⠀⠀
+        ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢮⣤⡾⠀⠀⣠⡴⠋⠀⡠⣚⠥⠒⢛⡲⠄⠀⠈⢻⡆⠀⠀⠻⣦⣀⠀⠀⠀⣿⠻⣦⣀⣴⠶⠂⠀⠘⣷⡄⠀⠀⢀⣴⡿⠈⠢⡀⠀⠀⠀⠀⠀⠀
+        ⠀⠀⠀⠀⠀⠀⠀⡠⠖⣉⣁⡀⠀⢀⣾⠋⠴⢿⣽⠋⠀⠞⢉⣉⣽⣳⣄⣀⠀⠋⠀⠀⠀⠈⠙⣷⡄⠀⠁⠀⠙⢤⣯⡀⠀⠀⠀⣼⡇⠀⡾⠋⠁⠀⠳⣄⠘⢆⠀⠀⠀⠀⠀
+        ⠀⠀⠀⠀⠀⡰⠋⠰⠛⢻⡞⢉⣠⣼⡇⢀⣴⠟⠛⠒⣴⠟⠋⠉⠀⠀⢀⣀⣀⡀⠀⠀⠀⠀⠀⣸⡇⠀⠀⠳⣄⠀⠉⢿⣄⠀⢰⣿⣧⡀⠀⣴⠶⠶⣦⡼⢧⠈⢣⠀⠀⠀⠀
+        ⠀⠀⠀⢀⡞⣡⣶⡄⠀⡟⣳⠿⠋⠙⡍⡽⠁⣀⣤⣤⣿⡄⠀⠀⠀⠀⡿⡉⣀⣀⣤⣤⣤⣴⠾⠥⠽⣦⣄⠀⠉⠻⢶⡼⢻⠀⠈⠇⠘⡷⡄⠘⠂⠀⢀⡍⠻⣷⣄⡇⠀⠀⠀
+        ⠀⠀⠀⠘⣺⠏⢸⢃⣼⠟⢁⡤⠀⣠⢟⡷⠟⢋⣉⣤⡿⠇⠀⠀⠀⢰⣣⠞⠋⠉⠉⠁⡀⠀⠀⠀⠀⠀⠙⢷⣄⠀⠀⢹⣾⠀⠀⠀⠀⢸⡇⠀⣀⡀⣾⠀⠀⠈⢻⡁⢦⠀⠀
+        ⠀⠀⣠⢚⣵⣄⠈⣼⡇⠀⢸⠧⢞⡵⠋⠠⠚⠉⠉⠀⠀⢀⡇⠀⣰⣟⣁⣀⠀⠀⠀⠀⠉⠒⠶⣤⣤⣀⠀⠀⠙⠀⠀⢸⡇⢰⣟⠛⢶⡋⣇⠀⠉⠻⡟⡄⠀⢀⢀⣿⠀⢧⠀
+        ⠀⣰⠃⢸⠁⣿⠀⠸⣧⠀⢸⢣⠋⠀⣠⣤⠶⢶⢒⣤⣔⣻⠣⢼⠟⠁⠀⠙⢷⡄⠀⠀⢀⠀⠀⠀⠈⠓⢟⢦⠀⠀⠀⢸⡇⠈⠻⣦⡀⠈⠻⣷⣄⠀⠘⣿⠀⠸⣿⣇⣀⢸⠀
+        ⠀⡇⠀⠀⣼⠇⠀⢀⣿⠀⣇⣇⣴⠟⠋⢠⣾⠟⠉⠀⠀⠈⠳⣼⠀⠀⠀⠀⠀⠳⠀⠀⠈⢳⣄⠀⠀⠀⢸⣼⠀⠀⠀⠈⡟⢆⠀⠈⢻⡀⠀⠈⢻⣆⠀⣻⠃⠀⠀⢹⡟⠻⡀
+        ⠀⢧⡆⣼⠏⠀⣾⠟⠁⢰⠃⡵⠃⢀⣴⡿⠁⠀⡀⠀⠀⠀⠀⠹⣧⡀⠰⣦⡀⠀⠀⠀⠀⠀⣻⢦⣀⣠⡾⣇⠀⠀⢀⣰⠟⠙⢷⣄⠀⠀⠀⠀⠀⣿⠀⠉⢠⠄⠀⣼⡇⠀⢧
+        ⢀⠞⢡⡟⠀⠀⣿⠀⢀⡏⡼⠁⣴⠟⠁⠀⠀⠀⣿⠀⣀⣀⢀⣴⠘⣷⡀⠈⢻⣦⣀⠀⢀⣾⠟⠉⠀⠀⠉⠻⣷⣄⠀⠀⠀⠀⠀⠙⢷⡄⠀⠀⠀⠉⠀⣠⡟⠀⣼⣟⠀⠀⢸
+        ⢸⠀⠘⣧⠀⡴⠛⠳⢸⢰⠁⢰⠏⠀⠀⠀⢀⣼⡯⠟⠋⠙⠻⣷⡀⠘⠀⠀⠀⠈⠉⠻⣿⠁⠀⠀⢰⡟⠉⠀⠈⢻⣦⠀⠀⠀⣄⠀⠀⡗⠀⢸⡇⣠⣾⠟⢀⣾⠋⠹⣷⢀⡇
+        ⠈⢆⠀⠹⢷⣤⣀⣠⠎⡇⠀⠸⠀⠀⢀⣴⠟⠉⠀⠀⠀⢄⠀⠹⣧⡀⠀⠀⣀⡀⠀⠀⣿⠀⠀⠀⠘⣿⡄⠀⠀⠀⢹⣦⡀⠀⢿⣄⠀⢀⣠⡿⠽⣯⡁⠀⠸⠃⠀⠀⡏⠉⠀
+        ⠀⢠⢷⣄⠀⠈⣉⣉⢢⢳⡀⠀⠀⠀⣾⡏⠀⠀⠠⣀⡤⢿⠀⠀⠙⠷⠶⠛⠉⠈⠀⣰⠟⠀⠀⠀⠀⠘⣷⡀⠀⠠⠛⠉⠉⠀⢈⣯⠗⠛⠁⠀⠀⠈⠃⠀⢀⣴⠇⢠⠇⠀⠀
+        ⠀⢸⡀⠻⣧⠈⠉⠹⣏⢀⣑⠤⣀⣀⠼⠳⣄⠀⠀⠀⠙⠺⠖⣦⣤⠤⣀⡀⠀⠀⠘⠁⠀⠀⠀⠀⠀⠀⢸⢧⡀⠀⠀⢀⣀⢴⣿⣅⡀⠠⠶⢿⢦⣀⣠⣴⠟⠃⡠⠋⠀⠀⠀
+        ⠀⠀⠳⡀⠘⠃⠀⡤⠸⣼⠀⠉⠛⠋⠉⠉⠙⠻⣦⣄⠀⠀⠀⠀⠈⠉⠙⠻⣦⠀⠀⠀⠀⡀⠀⠀⠀⢀⣾⠖⠚⠛⠛⠛⠋⠁⠀⠙⣷⠀⠀⣸⡴⠛⠉⢁⡤⠊⠁⠀⠀⠀⠀
+        ⠀⠀⠀⠘⢦⡀⠸⣧⠀⢻⢇⠀⠳⡤⣤⠆⠀⠀⠈⢻⡇⠀⠀⠀⢰⡄⠀⠀⣿⡇⢀⡾⠛⠛⠻⡝⣲⠟⠋⠀⢀⡄⠀⠀⠀⣀⡄⠀⠋⢀⡴⣻⡄⣤⡶⡍⠀⠀⠀⠀⠀⠀⠀
+        ⠀⠀⠀⠀⠀⠈⠙⠁⠉⠉⠈⠣⡀⠹⣇⠀⠀⠀⠀⠘⠀⠀⠀⢀⡾⢳⡶⠾⠋⠀⠈⠃⠀⠀⣠⠟⢄⣀⣠⡴⠋⠀⠀⠀⣼⢻⣤⣴⠶⠟⠋⣡⡷⣏⢿⡧⠀⠀⠀⠀⠀⠀⠀
+        ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠈⠓⢫⣲⣤⣀⣀⣀⣀⣤⣶⣻⠋⠛⠷⣦⣤⣤⣄⡤⢤⣺⠕⠋⠉⠉⠁⠀⠀⣀⣤⣾⠏⢩⠀⠀⢀⣤⣾⠛⣧⢻⣼⠀⠀⠀⠀⠀⠀⠀⠀
+        ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠈⠓⠮⢭⣉⣉⡩⠥⠚⠈⢇⠀⢠⡄⠀⠉⠉⠙⣿⠀⢠⠶⠖⢫⣩⠟⠛⠛⠉⠀⣠⣿⣦⠶⠿⣭⣸⣇⡿⠞⠁⠀⠀⠀⠀⠀⠀⠀⠀
+        ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠈⠳⣌⡿⣄⠀⠒⠚⠋⠀⠀⠀⣠⡾⠃⠀⢀⣀⠴⠚⠉⠣⢍⣛⣶⡶⠝⠃⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
+        ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠙⠒⠂⠀⠒⠒⠉⠀⠉⠉⠉⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀   
+                          
                                   FDP Agent Memory - By Future Development Program Kft.`;

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

@@ -48,7 +48,7 @@ class FAM_AutoCapture_ControlService {
         const contentHash = ingest_1.FAM_ContentHash_Util.hash(content);
         // Dedup: van-e MÁR aktív memory-bejegyzés azonos content-hash-sel? → idempotens skip (nincs duplikátum).
         const existing = await this.findByHash(contentHash);
-        if (existing && existing._id) {
+        if (existing?._id) {
             return { captured: false, skipped: 'duplicate', id: existing._id, contentHash: contentHash };
         }
         // Új capture → a `write` create-úton (agent-provenance, auto-embed). A `source.path` a sessionId

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

@@ -215,7 +215,7 @@ class FAM_EmbeddingPipeline_ControlService {
     }
     /** A scope-szűkítő filter (a `scopePath` LEVÉL scopeId-jára). Üres scope → teljes tár (`!_deleted`). */
     buildScopeFilter(scopePath) {
-        if (scopePath && scopePath.length) {
+        if (scopePath?.length) {
             const leaf = scopePath[scopePath.length - 1];
             const filter = { 'scopePath.scopeId': leaf.scopeId };
             return filter;

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

@@ -2,8 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FAM_Entry_DataService = void 0;
 const tslib_1 = require("tslib");
-const nts_dynamo_1 = require("@futdevpro/nts-dynamo");
 const mongoose_1 = tslib_1.__importDefault(require("mongoose"));
+const nts_dynamo_1 = require("@futdevpro/nts-dynamo");
 const fam_entry_data_model_1 = require("../../../_models/data-models/fam-entry.data-model");
 /**
  * `FAM_Entry_DataService` (SP-2.2) — egy GENERIKUS, tár-paraméteres entry-CRUD a vektor-rétegnek.
@@ -195,5 +195,27 @@ class FAM_Entry_DataService extends nts_dynamo_1.DyNTS_DataService {
         filterBy['position.charStart'] = { $ne: position.charStart };
         await this.updateData({ filterBy: filterBy, update: update });
     }
+    /**
+     * A **git-repo provenance** (`source.repoUrl` / `repoName` / `repoRelativePath` / `repoBranch`) FELTÉTELES
+     * backfill-je (user-FR 2026-06-22) — a re-scan `equal` (változatlan-content) ágán hívva, hogy a CSAK-metaadat
+     * frissítés (a git-provenance feature ELŐTT ingestelt korpuszra) RE-EMBED NÉLKÜL megtörténjen. A hívó (ingest)
+     * adja a kiszámolt `git`-mezőket (a `FAM_GitRepo_Util`-t a control-service importálja — nincs modul-ciklus). Nem
+     * git-repo (nincs `repoUrl`) → no-op. Feltétel: a per-fájl `repoRelativePath` `$ne` (a Mongo no-op, ha már stimmel).
+     */
+    async backfillGitProvenance(id, git) {
+        if (!git.repoUrl) {
+            return;
+        }
+        const setBlock = {
+            ['source.repoUrl']: git.repoUrl,
+            ['source.repoName']: git.repoName,
+            ['source.repoRelativePath']: git.repoRelativePath,
+            ['source.repoBranch']: git.repoBranch,
+        };
+        const update = { $set: setBlock };
+        const filterBy = { _id: id };
+        filterBy['source.repoRelativePath'] = { $ne: git.repoRelativePath };
+        await this.updateData({ filterBy: filterBy, update: update });
+    }
 }
 exports.FAM_Entry_DataService = FAM_Entry_DataService;

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

@@ -373,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.
@@ -479,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({

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;

package/build/src/_modules/scope-reference/_services/fam-scope-maintenance.control-service.js

@@ -0,0 +1,190 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FAM_ScopeMaintenance_ControlService = void 0;
+const tslib_1 = require("tslib");
+const mongoose_1 = tslib_1.__importDefault(require("mongoose"));
+const error_codes_const_1 = require("../../../_collections/error-codes.const");
+const fam_error_factory_util_1 = require("../../../_collections/fam-error-factory.util");
+const embedding_1 = require("../../embedding");
+const fam_reference_data_service_1 = require("./fam-reference.data-service");
+const fam_scope_data_service_1 = require("./fam-scope.data-service");
+const fam_scope_normalize_util_1 = require("../_collections/fam-scope-normalize.util");
+const fam_scope_maintenance_util_1 = require("../_collections/fam-scope-maintenance.util");
+/**
+ * `FAM_ScopeMaintenance_ControlService` (user-FR 2026-06-22) — **scope rename + merge** maintenance-engine.
+ * A claude-mem import (és egyéb) rendetlen scope-neveit (pl. `10.3.3` → valójában ccap-revisioned) rendezi:
+ * a `canonicalName`-t a denormalizált `scopePath[]`-en (MINDEN RAG-entry) + a reference `canonicalScopeRef`-jén
+ * + a scope-doc-on bulk-ban átírja (rename), VAGY egy scope-ot egy másikba olvaszt (merge → a forrás-scope
+ * minden entry-je az `into`-ra mutat, majd a forrás-scope soft-delete).
+ *
+ * **dryRun (default true a destruktív-biztonsághoz):** csak az érintett-számokat adja vissza, NEM ír. A
+ * tényleges íráshoz `dryRun:false` explicit. A bulk array-update mongoose `updateMany` + `arrayFilters` (a spec
+ * a tiszta `FAM_ScopeMaintenance_Util`-ból). A LVS-pool a Mongo-ból hidratál → a változás a következő (vagy
+ * scope-scoped) keresésnél él; nagy átírás után szerver-restart ajánlott a pool friss scope-metaadatához.
+ *
+ * **Megjegyzés (dedup):** a merge NEM dedup-ol — ha az `into` és a `from` ugyanazt a tartalmat tartalmazta,
+ * a `deduplicate_entries` (külön capability) felel a content-hash-összevonásért.
+ */
+class FAM_ScopeMaintenance_ControlService {
+    static _instance;
+    issuer = 'FAM_ScopeMaintenance_ControlService';
+    static getInstance() {
+        if (!FAM_ScopeMaintenance_ControlService._instance) {
+            FAM_ScopeMaintenance_ControlService._instance = new FAM_ScopeMaintenance_ControlService();
+        }
+        return FAM_ScopeMaintenance_ControlService._instance;
+    }
+    /**
+     * Egy scope ÁTNEVEZÉSE: a `scopeId` `canonicalName`-jét `newName`-re — a scopeId VÁLTOZATLAN, csak a
+     * denormalizált név (entry-k `scopePath` + reference + scope-doc). `dryRun` → csak az érintett-szám.
+     */
+    async renameScope(set) {
+        const newName = (set.newName ?? '').trim();
+        if (!newName) {
+            throw this.invalid('A `newName` (nem-üres string) KÖTELEZŐ a rename_scope-hoz.', 'rename_scope');
+        }
+        const scope = await this.resolveScope(set);
+        const scopeId = scope._id;
+        const dryRun = set.dryRun !== false;
+        const affected = await this.countAffected(scopeId);
+        if (!dryRun) {
+            const entryUpdate = fam_scope_maintenance_util_1.FAM_ScopeMaintenance_Util.renameEntryUpdate(scopeId, newName);
+            await this.applyEntryUpdate(entryUpdate);
+            const refUpdate = fam_scope_maintenance_util_1.FAM_ScopeMaintenance_Util.renameReferenceUpdate(scopeId, newName);
+            await this.referenceCollection().collection.updateMany(refUpdate.filter, refUpdate.update);
+            // A scope-doc canonicalName-je ($set, atomikus — a denormalizált forrás).
+            await new fam_scope_data_service_1.FAM_Scope_DataService({ issuer: this.issuer })
+                .updateData({ filterBy: { _id: scopeId }, update: { $set: { canonicalName: newName } } });
+        }
+        return {
+            operation: 'rename_scope',
+            dryRun: dryRun,
+            scope: { scopeId: scopeId, layer: scope.layer ?? '', oldName: scope.canonicalName ?? '', newName: newName },
+            affected: affected,
+            totalAffected: affected.reduce((sum, item) => sum + item.count, 0),
+        };
+    }
+    /**
+     * Két scope ÖSSZEOLVASZTÁSA: a `from` scope minden entry-je az `into` scope `{scopeId,layer,canonicalName}`-jére
+     * mutat, majd a `from` scope soft-delete. `dryRun` → csak az érintett-szám. Az `into` MARAD.
+     */
+    async mergeScopes(set) {
+        const from = await this.resolveScope(set.from);
+        const into = await this.resolveScope(set.into);
+        const fromId = from._id;
+        const intoId = into._id;
+        if (fromId === intoId) {
+            throw this.invalid('A `from` és az `into` ugyanaz a scope — nincs mit összeolvasztani.', 'merge_scopes');
+        }
+        const dryRun = set.dryRun !== false;
+        const intoRef = { scopeId: intoId, layer: into.layer ?? '', canonicalName: into.canonicalName ?? '' };
+        const affected = await this.countAffected(fromId);
+        if (!dryRun) {
+            const entryUpdate = fam_scope_maintenance_util_1.FAM_ScopeMaintenance_Util.mergeEntryUpdate(fromId, intoRef);
+            await this.applyEntryUpdate(entryUpdate);
+            const refUpdate = fam_scope_maintenance_util_1.FAM_ScopeMaintenance_Util.mergeReferenceUpdate(fromId, intoRef);
+            await this.referenceCollection().collection.updateMany(refUpdate.filter, refUpdate.update);
+            // A forrás-scope soft-delete (move-to-archive) — már nincs rá hivatkozó entry.
+            await new fam_scope_data_service_1.FAM_Scope_DataService({ issuer: this.issuer }).deleteData(fromId);
+        }
+        return {
+            operation: 'merge_scopes',
+            dryRun: dryRun,
+            from: { scopeId: fromId, layer: from.layer ?? '', canonicalName: from.canonicalName ?? '' },
+            into: { scopeId: intoId, layer: into.layer ?? '', canonicalName: into.canonicalName ?? '' },
+            affected: affected,
+            totalAffected: affected.reduce((sum, item) => sum + item.count, 0),
+            fromScopeDeleted: !dryRun,
+        };
+    }
+    /** Az `entryUpdate` spec alkalmazása MINDEN fő RAG-tár collection-jén (mongoose `updateMany` + arrayFilters). */
+    async applyEntryUpdate(entryUpdate) {
+        for (const named of this.entryCollections()) {
+            await named.collection.updateMany(entryUpdate.filter, entryUpdate.update, { arrayFilters: entryUpdate.arrayFilters });
+        }
+    }
+    /** A `scopeId`-t hivatkozó aktív entry-k száma per-collection (a 6 fő tár + a reference). */
+    async countAffected(scopeId) {
+        const affected = [];
+        for (const named of this.entryCollections()) {
+            affected.push({ collection: named.name, count: await named.collection.countDocuments({ 'scopePath.scopeId': scopeId }) });
+        }
+        const reference = this.referenceCollection();
+        affected.push({ collection: reference.name, count: await reference.collection.countDocuments({ 'canonicalScopeRef.scopeId': scopeId }) });
+        return affected;
+    }
+    /** A 6 fő RAG-tár mongoose-collection-jei (a DS-példányosítás regisztrálja a modellt, onnan a valós collection). */
+    entryCollections() {
+        const result = [];
+        for (const entry of embedding_1.FAM_STORE_REGISTRY) {
+            new embedding_1.FAM_Entry_DataService({ dataParams: entry.dataParams, issuer: this.issuer });
+            const model = mongoose_1.default.models[entry.dataParams.dataName];
+            if (model?.collection) {
+                result.push({ name: model.collection.collectionName, collection: model.collection });
+            }
+        }
+        return result;
+    }
+    /** A reference helper-tár mongoose-collection-je. */
+    referenceCollection() {
+        new fam_reference_data_service_1.FAM_Reference_DataService({ issuer: this.issuer });
+        const model = mongoose_1.default.models['fam_reference'];
+        return { name: model?.collection?.collectionName ?? 'fam_references', collection: model.collection };
+    }
+    /**
+     * Egy scope feloldása a szelektorból: `scopeId` (közvetlen) VAGY `layer`+`canonicalName` (egyértelmű) VAGY
+     * csak `canonicalName` (minden layer-en, normalizált-egyezés — egyértelmű kell legyen). Nem-talált/kétértelmű → hiba.
+     */
+    async resolveScope(selector) {
+        const dataService = new fam_scope_data_service_1.FAM_Scope_DataService({ issuer: this.issuer });
+        if (selector.scopeId) {
+            const scope = await dataService.findScopeById(selector.scopeId);
+            if (scope?._id) {
+                return scope;
+            }
+            throw this.notFound(`scopeId '${selector.scopeId}'`);
+        }
+        if (selector.canonicalName) {
+            const matches = selector.layer
+                ? await dataService.findByCanonical(selector.layer, selector.canonicalName)
+                : await this.findByNameAnyLayer(dataService, selector.canonicalName);
+            if (matches.length === 1) {
+                return matches[0];
+            }
+            if (matches.length > 1) {
+                throw fam_error_factory_util_1.FAM_Error_Util.create({
+                    errorCode: error_codes_const_1.FAM_ERROR_CODES.refResolveAmbiguous,
+                    message: `A(z) '${selector.canonicalName}' név több scope-ra illeszkedik (${matches.length}) — adj meg `
+                        + '`layer`-t vagy `scopeId`-t az egyértelműsítéshez.',
+                    issuer: this.issuer,
+                    context: { operation: 'scope-maintenance:resolve' },
+                });
+            }
+            throw this.notFound(`'${selector.canonicalName}'${selector.layer ? ` (layer '${selector.layer}')` : ''}`);
+        }
+        throw this.invalid('Add meg a scope-ot: `scopeId` VAGY `canonicalName` (+ opcionális `layer`).', 'resolve-scope');
+    }
+    /** Egy név normalizált-egyezése MINDEN aktív scope-on (layer nélkül; a halmaz kicsi). */
+    async findByNameAnyLayer(dataService, name) {
+        const all = await dataService.findAllActive();
+        const target = fam_scope_normalize_util_1.FAM_ScopeNormalize_Util.normalize(name);
+        return all.filter((scope) => fam_scope_normalize_util_1.FAM_ScopeNormalize_Util.normalize(scope.canonicalName ?? '') === target);
+    }
+    notFound(what) {
+        return fam_error_factory_util_1.FAM_Error_Util.create({
+            errorCode: error_codes_const_1.FAM_ERROR_CODES.refResolveNoMatch,
+            message: `Nincs aktív scope: ${what}.`,
+            issuer: this.issuer,
+            context: { operation: 'scope-maintenance:resolve' },
+        });
+    }
+    invalid(message, operation) {
+        return fam_error_factory_util_1.FAM_Error_Util.create({
+            errorCode: error_codes_const_1.FAM_ERROR_CODES.mcpDispatchUnknownCapability,
+            message: message,
+            issuer: this.issuer,
+            context: { operation: `scope-maintenance:${operation}` },
+        });
+    }
+}
+exports.FAM_ScopeMaintenance_ControlService = FAM_ScopeMaintenance_ControlService;

package/build/src/_modules/scope-reference/_services/fam-scope-resolver.control-service.js

@@ -409,7 +409,7 @@ class FAM_ScopeResolver_ControlService {
         }
         const scope_DS = new fam_scope_data_service_1.FAM_Scope_DataService({ issuer: this.issuer });
         const scope = await scope_DS.findScopeById(scopeId);
-        return Boolean(scope && scope._id);
+        return Boolean(scope?._id);
     }
     // =========================================================================
     // TRACE (dsgn-002 §4, dsgn-003 §4.2) — a debug-capability (MP-6) fogyasztja
@@ -460,7 +460,7 @@ class FAM_ScopeResolver_ControlService {
     async traceEntityFallback(rawLayer, scopeDataService) {
         const matches = await scopeDataService.findByCanonical(rawLayer.layer, rawLayer.rawName);
         const hit = matches.find((scope) => !!scope._id);
-        if (hit && hit._id) {
+        if (hit?._id) {
             return { matched: true, scopeId: hit._id, canonicalName: hit.canonicalName };
         }
         return { matched: false };

package/build/src/_modules/scope-reference/index.js

@@ -9,7 +9,7 @@
  * a fogyasztó-MP-ké. A reference/scope collection-ök MP-1-ben már a `dbModels`-ben vannak.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.FAM_FuzzyMatch_Util = exports.FAM_ScopeNormalize_Util = exports.FAM_ScopeResolver_ControlService = exports.FAM_Reference_DataService = exports.FAM_Scope_DataService = void 0;
+exports.FAM_FuzzyMatch_Util = exports.FAM_ScopeNormalize_Util = exports.FAM_ScopeMaintenance_ControlService = exports.FAM_ScopeResolver_ControlService = exports.FAM_Reference_DataService = exports.FAM_Scope_DataService = void 0;
 // SP-3.1 — Scope CRUD + scope-fa traverzál
 var fam_scope_data_service_1 = require("./_services/fam-scope.data-service");
 Object.defineProperty(exports, "FAM_Scope_DataService", { enumerable: true, get: function () { return fam_scope_data_service_1.FAM_Scope_DataService; } });
@@ -19,6 +19,9 @@ Object.defineProperty(exports, "FAM_Reference_DataService", { enumerable: true,
 // SP-3.3/SP-3.4 — a feloldó control-service (write-resolve / read-expand / cache / scopeExists / uncertainty)
 var fam_scope_resolver_control_service_1 = require("./_services/fam-scope-resolver.control-service");
 Object.defineProperty(exports, "FAM_ScopeResolver_ControlService", { enumerable: true, get: function () { return fam_scope_resolver_control_service_1.FAM_ScopeResolver_ControlService; } });
+// user-FR 2026-06-22 — scope rename/merge maintenance (rendetlen claude-mem import scope-nevek rendezése)
+var fam_scope_maintenance_control_service_1 = require("./_services/fam-scope-maintenance.control-service");
+Object.defineProperty(exports, "FAM_ScopeMaintenance_ControlService", { enumerable: true, get: function () { return fam_scope_maintenance_control_service_1.FAM_ScopeMaintenance_ControlService; } });
 // utils (SP-3.1/SP-3.2)
 var fam_scope_normalize_util_1 = require("./_collections/fam-scope-normalize.util");
 Object.defineProperty(exports, "FAM_ScopeNormalize_Util", { enumerable: true, get: function () { return fam_scope_normalize_util_1.FAM_ScopeNormalize_Util; } });

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

@@ -1,10 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Api_Controller = void 0;
+const tslib_1 = require("tslib");
+const mongoose_1 = tslib_1.__importDefault(require("mongoose"));
 const fsm_dynamo_1 = require("@futdevpro/fsm-dynamo");
 const nts_dynamo_1 = require("@futdevpro/nts-dynamo");
+const nts_dynamo_2 = require("@futdevpro/nts-dynamo");
 const fam_version_const_1 = require("../../../_collections/fam-version.const");
-const fam_heap_guard_control_service_1 = require("../../../_collections/fam-heap-guard.control-service");
 const fam_table_type_enum_1 = require("../../../_enums/fam-table.type-enum");
 const fam_config_level_type_enum_1 = require("../../../_enums/fam-config-level.type-enum");
 const config_control_service_1 = require("../config/config.control-service");
@@ -141,12 +143,12 @@ class Api_Controller extends nts_dynamo_1.DyNTS_Controller {
             endpoint: '/health',
             tasks: [
                 async (req, res) => {
-                    // A heap-nyomás IS kimegy a health-en (observability — a CLI/UI/agent látja a memória-állapotot).
-                    const memory = fam_heap_guard_control_service_1.FAM_HeapGuard_ControlService.getInstance().pressure();
+                    // A heap-nyomás IS kimegy a health-en (observability) — a BEDROCK DyNTS_MemoryGuard pressure-éből.
+                    const memory = nts_dynamo_2.DyNTS_MemoryGuard.getInstance().pressure();
                     res.send({
                         ok: true, service: 'fdp-agent-memory', version: fam_version_const_1.FAM_VERSION, uptime: process.uptime(),
-                        memory: { level: memory.level, usedMb: memory.usedMb, limitMb: memory.limitMb,
-                            ratio: Math.round(memory.ratio * 100) / 100, gcFraction: Math.round(memory.gcFraction * 100) / 100 },
+                        memory: { level: memory.level, heapUsedMb: memory.heapUsedMb, heapLimitMb: memory.heapLimitMb,
+                            heapPct: memory.heapPct, rssMb: memory.rssMb, gcFraction: memory.gcFraction },
                     });
                 },
             ],
@@ -193,13 +195,27 @@ class Api_Controller extends nts_dynamo_1.DyNTS_Controller {
         if (req.query.ingestRunId) {
             filter.ingestRunId = String(req.query.ingestRunId);
         }
-        const dataService = new embedding_1.FAM_Entry_DataService({ dataParams: registryEntry.dataParams, issuer: this.issuer });
-        const all = await dataService.findHydratableList(filter);
         const pageSize = Math.min(this.parseNumber(req.query.pageSize, DEFAULT_PAGE_SIZE), MAX_PAGE_SIZE);
         const page = Math.max(this.parseNumber(req.query.page, 1), 1);
         const start = (page - 1) * pageSize;
-        const items = all.slice(start, start + pageSize);
-        return { table: table, total: all.length, page: page, pageSize: pageSize, items: items };
+        // FIX (OOM): DB-OLDALI lapozás + `contentVector` projekció-kizárás. KORÁBBAN `findHydratableList({})` a TELJES
+        // tárat (126k+ teljes doc + 2560-dim vektor) memóriába töltötte ÉS memóriában szeletelt → a UI-polling többször
+        // GB-okat allokált → OOM + Mongo-flapping. Most: `countDocuments` + `skip/limit` + a nagy vektor-mező kihagyva.
+        const collection = this.entryCollection(registryEntry);
+        const total = await collection.countDocuments(filter);
+        const items = await collection
+            .find(filter, { projection: { contentVector: 0 } })
+            .sort({ __lastModified: -1 })
+            .skip(start)
+            .limit(pageSize)
+            .toArray();
+        return { table: table, total: total, page: page, pageSize: pageSize, items: items };
+    }
+    /** 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 });
+        const model = mongoose_1.default.models[registryEntry.dataParams.dataName];
+        return model.collection;
     }
     // =========================================================================
     // /stats · /stats/:table — high-level stats aggregátum (dsgn-011 §3/§4.4)
@@ -234,7 +250,11 @@ class Api_Controller extends nts_dynamo_1.DyNTS_Controller {
             ],
         });
     }
-    /** A tár-stats aggregátum (aktív elem-szám + embedding-státusz + utolsó ingest) — dsgn-011 §3/§4.4. */
+    /**
+     * A tár-stats aggregátum (aktív elem-szám + embedding-státusz + utolsó ingest) — dsgn-011 §3/§4.4.
+     * FIX (OOM): `countDocuments` + `$group`-aggregáció + 1-doc last-modified projekció — KORÁBBAN `findHydratableList({})`
+     * a TELJES tárat memóriába töltötte (a UI stats-pollingja → ismételt GB-allokáció → OOM). Most semmit nem hidratál.
+     */
     async collectTableStats(tables) {
         const result = [];
         for (const table of tables) {
@@ -242,24 +262,35 @@ class Api_Controller extends nts_dynamo_1.DyNTS_Controller {
             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({});
+            // Embedding-státusz bontás Mongo-aggregációval ($group), NEM a doc-ok memóriába töltésével.
             const byStatus = { pending: 0, completed: 0, error: 0 };
-            let lastModifiedMs = 0;
-            for (const entry of entries) {
-                const status = entry.embeddingStatus ?? 'pending';
-                byStatus[status] = (byStatus[status] ?? 0) + 1;
-                const modified = entry.__lastModified ? new Date(entry.__lastModified).getTime() : 0;
-                if (modified > lastModifiedMs) {
-                    lastModifiedMs = modified;
+            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;
                 }
             }
+            // Utolsó módosítás: EGYETLEN doc (a legfrissebb), csak az időbélyeg-mezőre projektálva.
+            const newest = await collection
+                .find({}, { projection: { __lastModified: 1 } })
+                .sort({ __lastModified: -1 })
+                .limit(1)
+                .toArray();
+            const lastModifiedMs = newest[0]?.__lastModified ? new Date(newest[0].__lastModified).getTime() : 0;
             result.push({
                 table: table,
-                count: entries.length,
+                count: count,
                 embeddingStatus: byStatus,
                 lastModified: lastModifiedMs ? new Date(lastModifiedMs).toISOString() : null,
-                status: entries.length ? 'ok' : 'empty',
+                status: count ? 'ok' : 'empty',
             });
         }
         return result;
@@ -434,14 +465,14 @@ class Api_Controller extends nts_dynamo_1.DyNTS_Controller {
         if (!Api_Controller.HEAVY_WRITE_OPERATIONS.includes(operation)) {
             return;
         }
-        const guard = fam_heap_guard_control_service_1.FAM_HeapGuard_ControlService.getInstance();
+        const guard = nts_dynamo_2.DyNTS_MemoryGuard.getInstance();
         if (!guard.shouldShedLoad()) {
             return;
         }
         const pressure = guard.pressure();
         throw new fsm_dynamo_1.DyFM_Error({
             errorCode: 'FAM-MEM-SHED-001',
-            message: `Memória-nyomás (${pressure.usedMb}/${pressure.limitMb} MB, ${Math.round(pressure.ratio * 100)}%, `
+            message: `Memória-nyomás (${pressure.heapUsedMb}/${pressure.heapLimitMb} MB, ${pressure.heapPct}%, `
                 + `GC ${Math.round(pressure.gcFraction * 100)}%) — a nehéz '${operation}' művelet ideiglenesen elutasítva `
                 + '(load-shed). Próbáld újra, amikor a nyomás enyhül (lásd /api/logs), vagy szakaszold a scant (cooldown).',
             issuer: this.issuer,

package/build/src/_routes/server/config/config.control-service.js

@@ -163,7 +163,7 @@ class FAM_Config_ControlService {
         const dataService = new config_data_service_1.FAM_Config_DataService({ issuer: options.issuer ?? this.issuer });
         // Régi aktív rekord (ha van) → soft-delete (archív; history-megőrzés, dsgn-007 §7.2).
         const existing = await dataService.findActive(filter);
-        if (existing && existing._id) {
+        if (existing?._id) {
             await dataService.deleteData(existing._id);
         }
         // Új aktív rekord — a `value` Mixed; a saveData $set-tel ír (Mongoose Mixed silent-drop ellen).
@@ -435,7 +435,7 @@ class FAM_Config_ControlService {
     async seedGlobalIfMissing(key, value) {
         const dataService = new config_data_service_1.FAM_Config_DataService({ issuer: this.issuer });
         const existing = await dataService.findActive({ level: fam_config_level_type_enum_1.FAM_ConfigLevel.global, key: key });
-        if (existing && existing._id) {
+        if (existing?._id) {
             return;
         }
         await this.set(key, value, { level: fam_config_level_type_enum_1.FAM_ConfigLevel.global, setBy: 'env-seed', issuer: this.issuer });

package/build/src/app.server.js

@@ -12,8 +12,6 @@ const errors_controller_1 = require("./_routes/server/errors/errors.controller")
 const errors_control_service_1 = require("./_routes/server/errors/errors.control-service");
 const server_status_controller_1 = require("./_routes/server/server-status/server-status.controller");
 const embedding_1 = require("./_modules/embedding");
-const config_control_service_1 = require("./_routes/server/config/config.control-service");
-const fam_heap_guard_control_service_1 = require("./_collections/fam-heap-guard.control-service");
 const environment_1 = require("./environments/environment");
 const title_const_1 = require("./_collections/title.const");
 /**
@@ -54,6 +52,30 @@ class App extends nts_dynamo_1.DyNTS_App {
         // lokális) lekérdezhetővé teszi → az agent IS olvashatja REST-en (nem csak a tmp-fájlból). Install + enable.
         nts_dynamo_1.DyNTS_global_settings.log_settings.logs_endpoint = { enabled: true };
         logs_1.DyNTS_Logs_Service.getInstance().install();
+        // OOM-hibakezelés a BEDROCK `DyNTS_MemoryGuard`-ból (a base App auto-installálja a startup-ban). FAM-specifikus
+        // hangolás: a GC-thrash a fő OOM-jel (a FAM korpusza nagy, a heap-% csak ~85%-on ütött, de GC ~0.87-en thrash-elt),
+        // ezért a GC-fraction-küszöbök a kritikusak; a `%`-küszöböt magasra tesszük (csak genuine-danger). A critical
+        // nyomás load-shed-eli a nehéz write-eket (scan/import) az api-controllerben, + crash-handler (uncaughtException →
+        // teljes-részletű error-entry) ON. **`exitOnSustainedCritical` ON** (nts-dynamo 1.15.74 boot-grace-szel): a FAM
+        // boot-hidratálása (126k vektor) ELEVE GC-thrash-el (mért gc≈0.87), ezért `bootGraceMs: 120000` — a ~80s hidratálás
+        // + margó alatt a sustained-critical NEM lép ki (csak logol + load-shed); a grace UTÁN a tartós critical TISZTÁN
+        // kilép (exit 137) → a `fam serve` ps1-wrapper prediktíven újraindít (a kriptikus OOM exit-134 helyett). Az eredeti
+        // OOM uptime 771s-nél volt — jóval a grace után, tehát kezelve.
+        nts_dynamo_1.DyNTS_global_settings.memoryGuard = {
+            enabled: true,
+            pollIntervalMs: 3000,
+            heapWarningThreshold: 80,
+            heapCriticalThreshold: 90,
+            recoveryMargin: 10,
+            maxHistoryCount: 100,
+            gcWarningFraction: 0.40,
+            gcCriticalFraction: 0.60,
+            installCrashHandlers: true,
+            exitOnSustainedCritical: true,
+            sustainedCriticalPolls: 3,
+            exitCode: 137,
+            bootGraceMs: 120000,
+        };
     }
     getGlobalServiceCollection() {
         return {
@@ -119,34 +141,11 @@ class App extends nts_dynamo_1.DyNTS_App {
      * át, amit a write/scan path (MP-4/MP-5) hív mentés után. Lásd a `_modules/embedding` modul-doksit.
      */
     async postProcess() {
-        // Heap-guard (OOM-hibakezelés) — a DB/config UTÁN, a (memória-igényes) pool-hidratálás ELŐTT telepítve, hogy
-        // a boot-növekedést is figyelje. A küszöbök a config-ból (memory.*), majd crash-handler + watchdog. Best-effort.
-        await this.installHeapGuard();
+        // Az OOM-hibakezelést (DyNTS_MemoryGuard) a base App auto-installálja a startup-ban, a FAM-hangolással
+        // (overrideDynamoNTSGlobalSettings → DyNTS_global_settings.memoryGuard) — itt nincs külön teendő.
         await embedding_1.FAM_EmbeddingBootstrap_ControlService.getInstance().boot();
         fsm_dynamo_1.DyFM_Log.S_info(`UI is available at: localhost:${environment_1.env.httpPort}/api/app`);
     }
-    /** A heap-guard küszöbeinek beolvasása a config-ból + telepítés. A config-hiba NEM buktatja a bootot (default-ok). */
-    async installHeapGuard() {
-        try {
-            const config = config_control_service_1.FAM_Config_ControlService.getInstance();
-            const num = async (key) => {
-                const resolved = await config.resolve(key, {});
-                return typeof resolved.value === 'number' ? resolved.value : undefined;
-            };
-            const enabledResolved = await config.resolve('memory.guardEnabled', {});
-            fam_heap_guard_control_service_1.FAM_HeapGuard_ControlService.getInstance().configure({
-                enabled: typeof enabledResolved.value === 'boolean' ? enabledResolved.value : undefined,
-                warnRatio: await num('memory.warnRatio'),
-                shedRatio: await num('memory.shedRatio'),
-                exitRatio: await num('memory.exitRatio'),
-                pollMs: await num('memory.pollMs'),
-            });
-        }
-        catch (error) {
-            fsm_dynamo_1.DyFM_Log.warn(`[heap-guard] config-olvasás sikertelen, default küszöbök: ${error?.message}`);
-        }
-        fam_heap_guard_control_service_1.FAM_HeapGuard_ControlService.getInstance().install();
-    }
     getGlobalErrorHandler() {
         return async (err, req, res, issuer) => {
             // No-silent-failure (dsgn-008): minden hibát persistálunk a `fam_errors` tárba a

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@futdevpro/fdp-agent-memory",
-  "version": "1.1.21",
+  "version": "1.1.30",
   "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": {
@@ -55,7 +55,7 @@
   "license": "FDP",
   "dependencies": {
     "@futdevpro/fsm-dynamo": "^1.16.7",
-    "@futdevpro/nts-dynamo": "^1.15.72",
+    "@futdevpro/nts-dynamo": "^1.15.74",
     "@modelcontextprotocol/sdk": "^1.12.0",
     "axios": "~1.8.1",
     "better-sqlite3": "^12.4.1",

package/build/src/_collections/fam-heap-guard.control-service.js

@@ -1,176 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.FAM_HeapGuard_ControlService = void 0;
-const tslib_1 = require("tslib");
-const v8 = tslib_1.__importStar(require("v8"));
-const perf_hooks_1 = require("perf_hooks");
-const fsm_dynamo_1 = require("@futdevpro/fsm-dynamo");
-/**
- * `FAM_HeapGuard_ControlService` (user-FR 2026-06-21) — **OOM-hibakezelés**. A FAM-szerver V8-heapje a nagy korpuszon
- * (126k vektor) + nehéz műveletekkor (scan/import/re-embed) a plafonhoz érhet → „Ineffective mark-compacts near heap
- * limit" → FATAL exit 134 (nem catch-elhető). Ez a guard:
- *
- * 1. **Watchdog**: periodikusan méri a heap-arányt (`v8.getHeapStatistics`) ÉS a GC-hányadot (`perf_hooks` 'gc'
- *    observer — a thrash valódi jele: a trace-ben `mu = 0.306`, azaz a futás 70%-a GC). A szint-váltásokat logolja
- *    (a `/api/logs`-on az agent IS látja jönni a nyomást).
- * 2. **Load-shed**: `shouldShedLoad()` → a NEHÉZ write-ek (scan/import/re-embed) `critical` nyomásnál 503-mal
- *    elutasítva, MIELŐTT egy újabb nagy allokáció átlöki a plafont (a könnyű read/create/update fut tovább).
- * 3. **Graceful exit**: ha a nyomás a `exitRatio` fölött tartós (GC-vel sem csökken), strukturált diagnosztika +
- *    tiszta `process.exit` → a `fam serve` ps1-wrapper PREDIKTÍVAN újraindít (a kriptikus exit-134 helyett).
- * 4. **Crash-handler**: `uncaughtException` / `unhandledRejection` → strukturált log + tiszta exit (eddig néma volt).
- *
- * Lokális, single-user (ADR-004) → a load-shed a saját gépet védi, nem multi-tenant fairness. A küszöbök
- * config-/env-kapcsolósak; a tiszta szint-számítás (`computeLevel`) pure + külön tesztelt.
- */
-class FAM_HeapGuard_ControlService {
-    static _instance;
-    /** GC-hányad-küszöb a `warn`/`critical` szinthez (a thrash-jelhez; a ratio MELLETT). */
-    static GC_WARN_FRACTION = 0.40;
-    static GC_CRITICAL_FRACTION = 0.60;
-    thresholds = {
-        warnRatio: 0.70, shedRatio: 0.82, exitRatio: 0.92, pollMs: 3000, enabled: true,
-    };
-    installed = false;
-    timer;
-    gcObserver;
-    lastLevel = 'ok';
-    /** A GC-ben töltött ms gördülő ablaka (timestamp + duration párok az utolsó ~pollMs-re). */
-    gcEvents = [];
-    static getInstance() {
-        if (!FAM_HeapGuard_ControlService._instance) {
-            FAM_HeapGuard_ControlService._instance = new FAM_HeapGuard_ControlService();
-        }
-        return FAM_HeapGuard_ControlService._instance;
-    }
-    /** A küszöbök beállítása (install ELŐTT) — clamp `[0..1]` (a pollMs `[500..60000]`). Hiányzó mező → marad a default. */
-    configure(partial) {
-        const clampRatio = (value, fallback) => (typeof value === 'number' && value > 0 && value <= 1) ? value : fallback;
-        this.thresholds = {
-            warnRatio: clampRatio(partial.warnRatio, this.thresholds.warnRatio),
-            shedRatio: clampRatio(partial.shedRatio, this.thresholds.shedRatio),
-            exitRatio: clampRatio(partial.exitRatio, this.thresholds.exitRatio),
-            pollMs: typeof partial.pollMs === 'number' && partial.pollMs >= 500
-                ? Math.min(partial.pollMs, 60000) : this.thresholds.pollMs,
-            enabled: typeof partial.enabled === 'boolean' ? partial.enabled : this.thresholds.enabled,
-        };
-    }
-    /** A crash-handlerek + (ha enabled) a watchdog + GC-observer telepítése. Idempotens (egyszer fut). Best-effort. */
-    install() {
-        if (this.installed) {
-            return;
-        }
-        this.installed = true;
-        process.on('uncaughtException', (error) => this.onFatal('uncaughtException', error));
-        process.on('unhandledRejection', (reason) => this.onFatal('unhandledRejection', reason));
-        if (!this.thresholds.enabled) {
-            fsm_dynamo_1.DyFM_Log.info('[heap-guard] disabled (memory.guardEnabled=false) — csak a crash-handlerek aktívak.');
-            return;
-        }
-        this.installGcObserver();
-        this.timer = setInterval(() => this.tick(), this.thresholds.pollMs);
-        // A timer NE tartsa életben a process-t (a graceful shutdownt ne blokkolja).
-        this.timer.unref?.();
-        fsm_dynamo_1.DyFM_Log.info(`[heap-guard] aktív (poll ${this.thresholds.pollMs}ms; shed@${Math.round(this.thresholds.shedRatio * 100)}%, `
-            + `exit@${Math.round(this.thresholds.exitRatio * 100)}%).`);
-    }
-    /** Pure szint-számítás (külön tesztelhető): a ratio ÉS a GC-hányad közül a ROSSZABB dönt. */
-    static computeLevel(ratio, gcFraction, thresholds) {
-        if (ratio >= thresholds.shedRatio || gcFraction >= FAM_HeapGuard_ControlService.GC_CRITICAL_FRACTION) {
-            return 'critical';
-        }
-        if (ratio >= thresholds.warnRatio || gcFraction >= FAM_HeapGuard_ControlService.GC_WARN_FRACTION) {
-            return 'warn';
-        }
-        return 'ok';
-    }
-    /** A pillanatnyi heap-nyomás (ratio + GC-hányad → szint). Observability + load-shed forrása. */
-    pressure() {
-        const stats = v8.getHeapStatistics();
-        const usedMb = Math.round(stats.used_heap_size / 1048576);
-        const limitMb = Math.round(stats.heap_size_limit / 1048576);
-        const ratio = stats.heap_size_limit ? stats.used_heap_size / stats.heap_size_limit : 0;
-        const gcFraction = this.recentGcFraction();
-        const level = FAM_HeapGuard_ControlService.computeLevel(ratio, gcFraction, this.thresholds);
-        return { level: level, usedMb: usedMb, limitMb: limitMb, ratio: ratio, gcFraction: gcFraction };
-    }
-    /** `true` → a NEHÉZ write-eket (scan/import/re-embed) le kell shed-elni (critical nyomás). Disabled → soha. */
-    shouldShedLoad() {
-        return this.thresholds.enabled && this.pressure().level === 'critical';
-    }
-    /** A GC-hányad az utolsó `pollMs` ablakban (GC-ms / ablak-ms; clamp [0..1]). */
-    recentGcFraction() {
-        const windowMs = this.thresholds.pollMs;
-        const cutoff = Date.now() - windowMs;
-        this.gcEvents = this.gcEvents.filter((event) => event.at >= cutoff);
-        const gcMs = this.gcEvents.reduce((sum, event) => sum + event.ms, 0);
-        return Math.min(gcMs / windowMs, 1);
-    }
-    /** A 'gc' perf-entry-k figyelése — a GC-ben töltött időt gyűjti a gördülő ablakhoz. */
-    installGcObserver() {
-        try {
-            this.gcObserver = new perf_hooks_1.PerformanceObserver((list) => {
-                const now = Date.now();
-                for (const entry of list.getEntries()) {
-                    this.gcEvents.push({ at: now, ms: entry.duration });
-                }
-            });
-            this.gcObserver.observe({ entryTypes: ['gc'] });
-        }
-        catch {
-            // A GC-observer nem kritikus (a ratio-jel marad) — best-effort.
-        }
-    }
-    /** A watchdog-tick: szint-váltás logolása + a tartós veszély-zóna graceful-exit-je. */
-    tick() {
-        const pressure = this.pressure();
-        if (pressure.level !== this.lastLevel) {
-            const line = `[heap-guard] ${this.lastLevel}→${pressure.level} `
-                + `(${pressure.usedMb}/${pressure.limitMb} MB ${Math.round(pressure.ratio * 100)}%, GC ${Math.round(pressure.gcFraction * 100)}%)`;
-            if (pressure.level === 'critical') {
-                fsm_dynamo_1.DyFM_Log.warn(`${line} — a nehéz write-ek (scan/import/re-embed) load-shed (503).`);
-            }
-            else if (pressure.level === 'warn') {
-                fsm_dynamo_1.DyFM_Log.warn(line);
-            }
-            else {
-                fsm_dynamo_1.DyFM_Log.info(`${line} — nyomás enyhült.`);
-            }
-            this.lastLevel = pressure.level;
-        }
-        // Tartós veszély-zóna: GC-kísérlet, majd ha nem csökken → tiszta, logolt exit (a ps1 újraindít).
-        if (pressure.ratio >= this.thresholds.exitRatio) {
-            this.attemptGcReclaim();
-            const after = this.pressure();
-            if (after.ratio >= this.thresholds.exitRatio) {
-                fsm_dynamo_1.DyFM_Log.error(`[heap-guard] HEAP-VÉSZ ${after.usedMb}/${after.limitMb} MB (${Math.round(after.ratio * 100)}%) — `
-                    + 'graceful exit, hogy a `fam serve` TISZTÁN újraindítson (a kriptikus OOM exit-134 elkerülése).');
-                // Egy tick haladékot adunk a log flush-nek, majd restartolható kóddal kilépünk.
-                setTimeout(() => process.exit(137), 250).unref?.();
-            }
-        }
-    }
-    /** Best-effort GC-kényszerítés (csak ha `--expose-gc`). A near-limit utolsó esély a tiszta-exit ELŐTT. */
-    attemptGcReclaim() {
-        try {
-            const maybeGc = global.gc;
-            if (maybeGc) {
-                maybeGc();
-            }
-        }
-        catch {
-            // nincs --expose-gc → nincs mit tenni; a tiszta-exit a fallback.
-        }
-    }
-    /** Strukturált crash-log + tiszta exit (a `fam serve` ps1 újraindít). Az OOM-fatal NEM ide jön (nem catch-elhető). */
-    onFatal(kind, error) {
-        try {
-            const message = error instanceof Error ? `${error.message}\n${error.stack ?? ''}` : String(error);
-            fsm_dynamo_1.DyFM_Log.error(`[heap-guard] FATAL ${kind}: ${message}`);
-        }
-        catch {
-            // a log se buktasson — best-effort.
-        }
-        setTimeout(() => process.exit(1), 250).unref?.();
-    }
-}
-exports.FAM_HeapGuard_ControlService = FAM_HeapGuard_ControlService;