@futdevpro/fdp-agent-memory 1.1.14 → 1.1.30

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,8 +1,11 @@
 "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_table_type_enum_1 = require("../../../_enums/fam-table.type-enum");
 const fam_config_level_type_enum_1 = require("../../../_enums/fam-config-level.type-enum");
@@ -104,6 +107,9 @@ class Api_Controller extends nts_dynamo_1.DyNTS_Controller {
                 async (req, res) => {
                     await this.run(res, async () => {
                         const input = (req.body ?? {});
+                        // Heap-load-shed (OOM-hibakezelés): a NEHÉZ write-eket (scan/import/re-embed) critical
+                        // memória-nyomásnál elutasítjuk (503), MIELŐTT egy nagy allokáció átlökné a plafont.
+                        this.assertHeapCapacity(String(input.operation));
                         return mcp_1.FAM_WriteTool_Service.getInstance().handle(input);
                     });
                 },
@@ -137,7 +143,13 @@ class Api_Controller extends nts_dynamo_1.DyNTS_Controller {
             endpoint: '/health',
             tasks: [
                 async (req, res) => {
-                    res.send({ ok: true, service: 'fdp-agent-memory', version: fam_version_const_1.FAM_VERSION, uptime: process.uptime() });
+                    // 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, heapUsedMb: memory.heapUsedMb, heapLimitMb: memory.heapLimitMb,
+                            heapPct: memory.heapPct, rssMb: memory.rssMb, gcFraction: memory.gcFraction },
+                    });
                 },
             ],
         });
@@ -183,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)
@@ -224,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) {
@@ -232,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;
@@ -406,11 +447,37 @@ class Api_Controller extends nts_dynamo_1.DyNTS_Controller {
             res.status(status).send({ ok: false, error: { errorCode: errorCode, message: message } });
         }
     }
-    /** A FAM hibakód → HTTP-státusz (a user/validation-hibák 400, a többi 500; dsgn-008). */
+    /** A FAM hibakód → HTTP-státusz (a memória-shed 503, a user/validation-hibák 400, a többi 500; dsgn-008). */
     httpStatusForCode(errorCode) {
+        if (errorCode.startsWith('FAM-MEM-SHED-')) {
+            return 503;
+        }
         const userPrefixes = ['FAM-VAL-', 'FAM-REF-RESOLVE-', 'FAM-SCOPE-WRITE-', 'FAM-MCP-DISPATCH-'];
         return userPrefixes.some((prefix) => errorCode.startsWith(prefix)) ? 400 : 500;
     }
+    /** A NEHÉZ write-ek (scan/import/re-embed) listája — a load-shed CSAK ezeket utasítja el (a könnyűek futnak). */
+    static HEAVY_WRITE_OPERATIONS = ['scan-file', 'scan-folder', 'scan-project', 'import', 're-embed'];
+    /**
+     * Heap-load-shed (OOM-hibakezelés): ha a `operation` NEHÉZ ÉS a heap-guard critical nyomást jelez → 503 `DyFM_Error`
+     * (a könnyű create/update/delete fut tovább). Így egy újabb nagy scan/import nem löki OOM-ba a már-feszített heapet.
+     */
+    assertHeapCapacity(operation) {
+        if (!Api_Controller.HEAVY_WRITE_OPERATIONS.includes(operation)) {
+            return;
+        }
+        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.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,
+        });
+    }
     /** A `:table` path-param → `FAM_Table` (ismeretlen → hiba). */
     parseTable(raw) {
         const match = Object.values(fam_table_type_enum_1.FAM_Table).find((table) => table === raw);

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

@@ -13,6 +13,7 @@ const errors_control_service_1 = require("./_routes/server/errors/errors.control
 const server_status_controller_1 = require("./_routes/server/server-status/server-status.controller");
 const embedding_1 = require("./_modules/embedding");
 const environment_1 = require("./environments/environment");
+const title_const_1 = require("./_collections/title.const");
 /**
  * FDP Agent Memory Server App — Pure Dynamo, **AUTH NÉLKÜL** (ADR-004).
  *
@@ -32,6 +33,7 @@ class App extends nts_dynamo_1.DyNTS_App {
         const mongoBase = process.env.MONGODB_URI || process.env.MONGO_URL || 'mongodb://0.0.0.0:29017';
         return new nts_dynamo_1.DyNTS_App_Params({
             name: 'FDP Agent Memory Server',
+            title: title_const_1.FAM_title,
             version: package_json_1.version,
             dbName: dbName,
             dbUri: `${mongoBase}/${dbName}`,
@@ -40,7 +42,7 @@ class App extends nts_dynamo_1.DyNTS_App {
     }
     overrideDynamoNTSGlobalSettings() {
         nts_dynamo_1.DyNTS_global_settings.log_settings.api_errors = false;
-        nts_dynamo_1.DyNTS_global_settings.log_settings.setup = true;
+        //DyNTS_global_settings.log_settings.setup = true;
         // NINCS JWT/auth check (ADR-004): a szerver lokális, single-user. Az auth-t EXPLICITEN
         // opcionálisnak jelöljük → elnémítja a minden booton megjelenő „Unique Authentication Service
         // missing!" figyelmeztetést (a no-auth a SZÁNDÉK, nem hiányosság).
@@ -50,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 {
@@ -115,7 +141,10 @@ 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() {
+        // 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`);
     }
     getGlobalErrorHandler() {
         return async (err, req, res, issuer) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@futdevpro/fdp-agent-memory",
-  "version": "1.1.14",
+  "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",