@futdevpro/fdp-agent-memory 0.1.0

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

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FAM_Config_DataService = void 0;
+const nts_dynamo_1 = require("@futdevpro/nts-dynamo");
+const fam_config_data_model_1 = require("../../../_models/data-models/fam-config.data-model");
+/**
+ * `FAM_Config_DataService` — a `fam_config` collection (MAIN) CRUD + soft-delete history-rétege (dsgn-007 §8).
+ *
+ * `extends DyNTS_DataService` (a MAIN collection service): a felülírt (régi) értékek soft-delete-elve
+ * a `*_archived` tárba mozognak (audit-trail, dsgn-007 §7.2). A move-to-archive a base `deleteData`
+ * (addArchive) → `getArchiveDataService()`-en át megy (lásd lentebb). Master-prompter mintára:
+ * constructor `{ data?, issuer }` → `super(data, dataParams, issuer)`.
+ *
+ * **FIGYELEM (memory: dynts_dataservice_eager_resolve):** a `DyNTS_DataService` base-ctor EAGER
+ * `getDBService`-t hív → a control-service NEM tarthat élő data-service-példányt mezőként; minden
+ * művelet előtt lazy `new FAM_Config_DataService(...)` kell (a control-service ezt teszi).
+ *
+ * **A `value` írása `$set`-tel atomikus** (Mongoose Mixed silent-drop ellen, dsgn-007 §2; memory:
+ * reference_mongoose_mixed_atomic_write) — `findOne→mutate→save` NEM.
+ */
+class FAM_Config_DataService extends nts_dynamo_1.DyNTS_DataService {
+    constructor(set) {
+        super(set.data instanceof fam_config_data_model_1.FAM_Config_DataModel ? set.data : new fam_config_data_model_1.FAM_Config_DataModel(set.data), fam_config_data_model_1.famConfig_dataParams, set.issuer);
+    }
+    /**
+     * A move-to-archive soft-delete (dsgn-007 §7.2) archív-collection service-e: a base `deleteData`
+     * (addArchive) ezt hívja, hogy a felülírt/törölt rekordot a `fam_config_archived` tárba mozgassa
+     * (history). A `DyNTS_DataService` base default-ja DOB (nincs ökoszisztéma-implementáció) — ezért
+     * kell az explicit override; a `DyNTS_ArchiveDataService` a `dataParams.addArchive`-ból oldja fel
+     * az archív-collection nevét. (Bedrock-igény: a base auto-wiringja — `BFR-AM-archive`.)
+     */
+    getArchiveDataService() {
+        return new nts_dynamo_1.DyNTS_ArchiveDataService(new fam_config_data_model_1.FAM_Config_DataModel(), this.dataParams, this.issuer);
+    }
+    /**
+     * Egy adott feloldási-kulcson (`level`+`tableScope`+`scopeId`+`key`) az AKTÍV (nem soft-delete-elt)
+     * rekord. A `_deleted` Date soft-delete marker; az aktív rekordon `_deleted` nincs beállítva.
+     */
+    async findActive(filter) {
+        return this.findData(filter, true);
+    }
+    /**
+     * Az adott szinten konfigurált ÖSSZES aktív rekord (a `resolveAll` egy Mongo-köre, dsgn-007 §3).
+     */
+    async findActiveList(filter) {
+        return this.findDataList(filter, true);
+    }
+}
+exports.FAM_Config_DataService = FAM_Config_DataService;

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

@@ -0,0 +1,123 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FAM_Error_ControlService = void 0;
+const error_banners_const_1 = require("../../../_collections/error-banners.const");
+const fam_error_factory_util_1 = require("../../../_collections/fam-error-factory.util");
+const errors_data_service_1 = require("./errors.data-service");
+/**
+ * `FAM_Error_ControlService` (dsgn-008 §6, SP-8.1/8.2/8.3). A `DyNTS_Errors_ControlService` mintára:
+ * a `globalErrorHandler` mögötti orchestráció + a réteg-emisszió + a felhasználói surfacing
+ * (banner-deszkriptorok + `list_errors`) belépési pontja. Singleton.
+ *
+ * **NEM tartunk élő `FAM_Error_DataService` mezőt** (memory: dynts_dataservice_eager_resolve — a
+ * base-ctor eager `getDBService`-t hív): minden DB-művelet előtt lazy `new FAM_Error_DataService`.
+ *
+ * Felelősségek:
+ * - **`handle`** (SP-8.1): a `globalErrorHandler` factory mögötti perzistálás-orchestráció (a
+ *   `FAM_Error_DataService.handleInternalError`-re — auto-dedup + occurrence-count a Dynamo-bázisból).
+ * - **`emit`** (SP-8.2): a réteg-szintű 3-lépéses szerződés EGY belépési pontja — snapshot-építés
+ *   (factory) → persist (`handle`) → a hívónak visszaadott kanonikus `DyFM_Error` (deskriptív,
+ *   nem-elnyelt). A réteg-MP-k ezt hívják, nem ad-hoc try/catch-elnyeléssel.
+ * - **`listErrors` / `markHandled`** (SP-8.3): a `list_errors` capability-handler (MP-6) + `/errors`
+ *   UI (MP-10) belépési logikája — listáz/szűr/"kezelve" jelöl (a Dynamo-bázis lekérdezésére építve).
+ * - **banner-deszkriptorok** (SP-8.3): a 3 nevesített banner-eset trigger→payload szerződése.
+ */
+class FAM_Error_ControlService {
+    static _instance;
+    /** Default issuer az error-műveletekhez (a `FAM_Error.source`/`issuer`-éhez). */
+    issuer = 'FAM_Error_ControlService';
+    static getInstance() {
+        if (!FAM_Error_ControlService._instance) {
+            FAM_Error_ControlService._instance = new FAM_Error_ControlService();
+        }
+        return FAM_Error_ControlService._instance;
+    }
+    // =========================================================================
+    // SP-8.1 — globalErrorHandler orchestráció (persist + dedup + occurrence)
+    // =========================================================================
+    /**
+     * A `globalErrorHandler` mögötti perzistálás (dsgn-008 §1/§4 2. lépés). A hibát a `fam_errors`
+     * tárba írja a `FAM_Error_DataService.handleInternalError`-en át — innen jön az **auto-dedup +
+     * occurrence-count** (azonos `message` → `count`-növelés, nem új rekord). `alwaysRecord=true`:
+     * a no-silent-failure mandátum miatt minden FAM-hibát perzistálunk (a dev-verzió-skip kikapcsolva).
+     */
+    async handle(error, issuer) {
+        const setIssuer = issuer ?? error?.___issuerService ?? this.issuer;
+        const error_DS = new errors_data_service_1.FAM_Error_DataService({ issuer: setIssuer });
+        await error_DS.handleInternalError(error, setIssuer, true);
+    }
+    // =========================================================================
+    // SP-8.2 — réteg-emisszió: a 3-lépéses szerződés EGY belépési pontja
+    // =========================================================================
+    /**
+     * A per-réteg egységes hiba-emisszió (dsgn-008 §4). A 3-lépéses szerződés:
+     * (1) **snapshot-építés** — a `FAM_Error_Util.create` a factory-n át (sensitive-szűrt context +
+     *     errorCode + réteg-default level), (2) **persist** — `handle` (a `fam_errors`-ba, dedup),
+     *     (3) **visszacsatolás** — a kanonikus `DyFM_Error`-t VISSZAADJA a hívónak (nem nyeli el),
+     *     hogy a réteg deskriptív hiba-blokkot/`ok:false`-t adhasson tovább (sosem üres `[]`).
+     *
+     * A réteg-MP-k ezt hívják (nem saját `new DyFM_Error` + try/catch-elnyelés). A tényleges
+     * réteg-emisszió a forrás-MP-kben él (MP-2 EMB, MP-3 REF, MP-4 SCAN, MP-6 MCP/VAL); MP-8 az
+     * infra (factory + handler + ez az `emit`).
+     */
+    async emit(params) {
+        // (1) snapshot-építés + kanonikus FAM error (a factory-n át).
+        const famError = fam_error_factory_util_1.FAM_Error_Util.create({
+            errorCode: params.errorCode,
+            message: params.message,
+            level: params.level,
+            context: params.context,
+            issuer: this.issuer,
+            cause: params.cause,
+        });
+        // (2) persist (dedup + occurrence-count a Dynamo-bázisból).
+        await this.handle(famError, this.issuer);
+        // (3) a hívónak VISSZAADOTT kanonikus hiba (deskriptív, nem elnyelt).
+        return famError;
+    }
+    // =========================================================================
+    // SP-8.3 — list_errors handler-logika + "kezelve" jelölés
+    // =========================================================================
+    /**
+     * A `list_errors` (dsgn-008 §5 / dsgn-003) handler-logikája: a `fam_errors` rekordok a
+     * `level`/`source`/`handled` szűrőkre. A capability-**regisztráció** MP-6-ban (dsgn-003
+     * capability-registry); ITT a handler-logika + a kiadott mező-halmaz (`message`/`stack`(
+     * `stackTrace`)/`errorCode`/`contextSnapshot`/`source`/`occurrenceCount`(`count`)/`instanceId`).
+     */
+    async listErrors(filter) {
+        const error_DS = new errors_data_service_1.FAM_Error_DataService({ issuer: this.issuer });
+        return error_DS.listErrors(filter);
+    }
+    /**
+     * Egy hiba "kezelve" (`handled:true`) jelölése (dsgn-008 §5). A `FAM_Error_DataService.markHandled`-re
+     * (atomic `$set`); a `list_errors` capability / `/errors` UI hívja (a "kezelve" round-trip).
+     */
+    async markHandled(errorId, handled = true) {
+        const error_DS = new errors_data_service_1.FAM_Error_DataService({ issuer: this.issuer });
+        await error_DS.markHandled(errorId, handled);
+    }
+    // =========================================================================
+    // SP-8.3 — banner-deszkriptorok (a felhasználói surfacing szerződés gazdája)
+    // =========================================================================
+    /** Egy nevesített banner-eset deszkriptora (a render-MP — MP-9/10 — ezt jeleníti meg). */
+    getBannerDescriptor(bannerCase) {
+        return error_banners_const_1.FAM_BANNER_DESCRIPTORS[bannerCase];
+    }
+    /** Mind a 3 nevesített banner-deszkriptor (a render-MP-knek). */
+    getAllBannerDescriptors() {
+        return Object.values(error_banners_const_1.FAM_BANNER_DESCRIPTORS);
+    }
+    /** A `level` → banner-szín leképezés (dsgn-008 §5): `user`/`warning` → sárga, egyéb → piros. */
+    bannerColorForLevel(level) {
+        return error_banners_const_1.FAM_Banner_Util.colorForLevel(level);
+    }
+    /**
+     * A `globalErrorHandler` factory (az `App.getGlobalErrorHandler` ezt használja). A
+     * `handle`-re delegál — egy hely a perzistálás-orchestrációnak. A `DyNTS_GlobalService` a
+     * startup-ban köti be (a `setServices.errorHandler`-en, az App-ban).
+     */
+    static async globalErrorHandler(error, issuer) {
+        await FAM_Error_ControlService.getInstance().handle(error, issuer);
+    }
+}
+exports.FAM_Error_ControlService = FAM_Error_ControlService;

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

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Errors_Controller = void 0;
+const fsm_dynamo_1 = require("@futdevpro/fsm-dynamo");
+const nts_dynamo_1 = require("@futdevpro/nts-dynamo");
+const errors_control_service_1 = require("./errors.control-service");
+/**
+ * `Errors_Controller` — a `fam_errors` REST-surface (dsgn-008 §5). **NEM** `DyNTS_Errors_Controller`
+ * extends (az 5+ built-in endpoint + auth-retrofit minta nem kell itt — lokális, single-user,
+ * auth-nélkül, ADR-004); a `FAM_Error_ControlService`-re épít (listáz/szűr/"kezelve").
+ *
+ * Az `/errors` UI (MP-10) + a `list_errors` capability (MP-6) a `FAM_Error_ControlService`-t
+ * használja; ez a controller a REST-belépőt adja a UI-nak (a 3 nevesített banner-render is innen
+ * fogyaszt majd, MP-10). Singleton: `getInstance()` → `getSingletonInstance()`.
+ */
+class Errors_Controller extends nts_dynamo_1.DyNTS_Controller {
+    static getInstance() {
+        return Errors_Controller.getSingletonInstance();
+    }
+    setupEndpoints() {
+        const error_CS = errors_control_service_1.FAM_Error_ControlService.getInstance();
+        this.endpoints = [
+            new nts_dynamo_1.DyNTS_Endpoint_Params({
+                name: 'listErrors',
+                type: fsm_dynamo_1.DyFM_HttpCallType.get,
+                endpoint: '/errors',
+                tasks: [
+                    async (req, res) => {
+                        // Szűrők a query-stringből (level / source / handled) — dsgn-008 §5.
+                        const filter = {
+                            level: req.query.level ? String(req.query.level) : undefined,
+                            source: req.query.source ? String(req.query.source) : undefined,
+                            handled: req.query.handled !== undefined ? req.query.handled === 'true' : undefined,
+                        };
+                        const list = await error_CS.listErrors(filter);
+                        res.send(list);
+                    },
+                ],
+            }),
+            new nts_dynamo_1.DyNTS_Endpoint_Params({
+                name: 'markErrorHandled',
+                type: fsm_dynamo_1.DyFM_HttpCallType.post,
+                endpoint: '/errors/mark-handled/:errorId',
+                tasks: [
+                    async (req, res) => {
+                        await error_CS.markHandled(req.params.errorId, true);
+                        res.send({ result: 'marked handled' });
+                    },
+                ],
+            }),
+            new nts_dynamo_1.DyNTS_Endpoint_Params({
+                name: 'listErrorBanners',
+                type: fsm_dynamo_1.DyFM_HttpCallType.get,
+                endpoint: '/errors/banners',
+                tasks: [
+                    async (req, res) => {
+                        // A 3 nevesített banner-deszkriptor (a render-szerződés; MP-10 fogyasztja).
+                        res.send(error_CS.getAllBannerDescriptors());
+                    },
+                ],
+            }),
+        ];
+    }
+}
+exports.Errors_Controller = Errors_Controller;

package/build/src/_routes/server/errors/errors.data-service.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FAM_Error_DataService = void 0;
+const fsm_dynamo_1 = require("@futdevpro/fsm-dynamo");
+const server_1 = require("@futdevpro/nts-dynamo/server");
+const fam_error_data_model_1 = require("../../../_models/data-models/fam-error.data-model");
+/**
+ * `FAM_Error_DataService` (dsgn-008 §6, SP-8.1) — a `fam_errors` collection error-rétege.
+ *
+ * **REUSE, NEM reinvent (dsgn-008 §1):** `extends DyNTS_Errors_DataService<DyFM_Error,
+ * FAM_Error_DataModel>` — a Dynamo error-pipeline-t örökli: az **auto-dedup + occurrence-count**
+ * (`recordError`/`handleInternalError`), a stringify-resilience, a priority-számítás mind a bázisból.
+ * Saját error-infra NEM épül. A bázis a `FAM_Error_DataModel` (`= DyFM_Errors<DyFM_Error>` + FAM-mezők)
+ * rekordon dolgozik, a `fam_errors` `dataParams`-szal.
+ *
+ * Master-prompter mintára: constructor `{ data?, issuer }` → `super(record, famError_dataParams, issuer)`.
+ *
+ * **FIGYELEM (memory: dynts_dataservice_eager_resolve):** a base-ctor EAGER `getDBService`-t hív →
+ * a control-service NEM tarthat élő data-service-példányt mezőként; minden művelet előtt lazy
+ * `new FAM_Error_DataService(...)`.
+ */
+class FAM_Error_DataService extends server_1.DyNTS_Errors_DataService {
+    constructor(set) {
+        super((set.data instanceof fam_error_data_model_1.FAM_Error_DataModel ? set.data : new fam_error_data_model_1.FAM_Error_DataModel(set.data)), fam_error_data_model_1.famError_dataParams, set.issuer);
+    }
+    /**
+     * A Dynamo-bázis `createErrorRecord`-ját kiterjeszti a FAM-specifikus mezőkkel (dsgn-008 §2): a
+     * `DyFM_Error.errorCode`-ot a rekord top-level `errorCode` mezőjébe, és a `contextSnapshot`-ot az
+     * `additionalContent.contextSnapshot`-ból (ahová a `FAM_Error_Util` factory tette) a rekord
+     * top-level `contextSnapshot` mezőjébe emeli. Így a `list_errors`/UI a dsgn-008 §2 mezőnevekkel
+     * olvashat, a dedup/occurrence pedig változatlanul a base-en fut (a dedup a `message`-re kulcsol).
+     */
+    async createErrorRecord(error, issuer) {
+        const baseRecord = await super.createErrorRecord(error, issuer);
+        const dyfmError = fsm_dynamo_1.DyFM_Error.isDyFMError(error) ? error : undefined;
+        // errorCode: a kanonikus FAM kódot (`FAM-<SVC>-<METHOD>-NNN`) a rekord top-level mezőjébe.
+        const errorCode = dyfmError?._errorCode ?? fsm_dynamo_1.DyFM_Error.getErrorCode(error);
+        if (errorCode) {
+            baseRecord.errorCode = errorCode;
+        }
+        // contextSnapshot: az additionalContent-ből (a factory ide tette) a top-level mezőbe.
+        const snapshot = dyfmError?.additionalContent?.contextSnapshot;
+        if (snapshot) {
+            baseRecord.contextSnapshot = snapshot;
+        }
+        // Új rekord default-ja: NEM kezelt (a dedup-ág a base-en nem nyúl ehhez).
+        baseRecord.handled ??= false;
+        return baseRecord;
+    }
+    /**
+     * A `list_errors` (dsgn-008 §5 / dsgn-003) adat-oldali lekérdezése: a `fam_errors` rekordok a
+     * `level`/`source`/`handled` szűrőkre (csak a megadott mezőkre szűr). A kiadott mező-halmaz a
+     * teljes `FAM_Error_DataModel` (`message`/`stack`(`stackTrace`)/`errorCode`/`contextSnapshot`/
+     * `source`/`occurrenceCount`(`count`)/`level`/`handled`); a capability/UI ezt vetíti le.
+     */
+    async listErrors(filter) {
+        const dbFilter = {};
+        if (filter?.level) {
+            dbFilter.level = filter.level;
+        }
+        if (filter?.source) {
+            dbFilter.source = filter.source;
+        }
+        if (filter?.handled !== undefined) {
+            dbFilter.handled = filter.handled;
+        }
+        return this.findDataList(dbFilter);
+    }
+    /**
+     * Egy hiba "kezelve" (`handled:true`) jelölése (dsgn-008 §5). A `DyNTS_Errors_DataService`-re
+     * építve (atomic `$set`), nem saját write-path. A `list_errors` capability / `/errors` UI hívja.
+     */
+    async markHandled(errorId, handled = true) {
+        await this.updateData({
+            filterBy: { _id: errorId },
+            update: { $set: { handled: handled } },
+        });
+    }
+}
+exports.FAM_Error_DataService = FAM_Error_DataService;

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

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ServerStatus_ControlService = void 0;
+/**
+ * ServerStatus_ControlService — singleton, project-specifikus statisztika lekérdezések.
+ *
+ * Master-prompter mintára: `getUserStatistics`, `getFlowStatistics`, `getRunStatistics`,
+ * stb. metódusok. A base osztály nélkül egyszerű singleton, project-specifikus metódusokkal.
+ */
+class ServerStatus_ControlService {
+    static _instance;
+    static getInstance() {
+        if (!ServerStatus_ControlService._instance) {
+            ServerStatus_ControlService._instance = new ServerStatus_ControlService();
+        }
+        return ServerStatus_ControlService._instance;
+    }
+}
+exports.ServerStatus_ControlService = ServerStatus_ControlService;

package/build/src/_routes/server/server-status/server-status.controller.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ServerStatus_Controller = void 0;
+const fsm_dynamo_1 = require("@futdevpro/fsm-dynamo");
+const nts_dynamo_1 = require("@futdevpro/nts-dynamo");
+const server_status_control_service_1 = require("./server-status.control-service");
+/**
+ * ServerStatus_Controller — saját status endpoint (Pure Dynamo, FDP-mentes).
+ *
+ * A jelenlegi `DyNTS_Controller` API: a `setupEndpoints()`-ben kell beállítani a
+ * `this.endpoints` listát (a base ctor hívja meg konstrukciókor).
+ */
+class ServerStatus_Controller extends nts_dynamo_1.DyNTS_Controller {
+    static getInstance() {
+        return ServerStatus_Controller.getSingletonInstance();
+    }
+    server_CS = server_status_control_service_1.ServerStatus_ControlService.getInstance();
+    setupEndpoints() {
+        this.endpoints = [
+            new nts_dynamo_1.DyNTS_Endpoint_Params({
+                name: 'getStatus',
+                type: fsm_dynamo_1.DyFM_HttpCallType.get,
+                endpoint: '/status',
+                tasks: [
+                    async (req, res, issuer) => {
+                        res.send({
+                            name: 'fdp-agent-memory-server',
+                            version: 'FDP Agent Memory v0.0.1',
+                            status: 'ok',
+                            uptime: process.uptime(),
+                            timestamp: new Date().toISOString(),
+                        });
+                    },
+                ],
+            }),
+        ];
+    }
+}
+exports.ServerStatus_Controller = ServerStatus_Controller;

package/build/src/app.server.js

@@ -0,0 +1,122 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.App = void 0;
+const fsm_dynamo_1 = require("@futdevpro/fsm-dynamo");
+const nts_dynamo_1 = require("@futdevpro/nts-dynamo");
+const package_json_1 = require("../package.json");
+const fam_db_models_const_1 = require("./_collections/fam-db-models.const");
+const api_controller_1 = require("./_routes/server/api/api.controller");
+const client_app_controller_1 = require("./_routes/server/client-app/client-app.controller");
+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 environment_1 = require("./environments/environment");
+/**
+ * FDP Agent Memory Server App — Pure Dynamo, **AUTH NÉLKÜL** (ADR-004).
+ *
+ * Lokális, single-user MCP-szerver REST/UI-rétege. `class App extends DyNTS_App`
+ * (NEM `FDPNTS_App` — nincs FDP-réteg; NEM `DyNTS_AppExtended` — nincs socket itt).
+ * NINCS auth: a `DyNTS_GlobalService_Settings.authService` opcionális, ezért kihagyjuk;
+ * a beépített Dynamo controller-ek (server-status, errors, test, usage) publikusak
+ * default-ból. A vektor-RAG `FAM_*` dataParams-ek + MCP transport MP-1 / MP-6 feladata —
+ * itt csak a connect + app-csontváz.
+ */
+class App extends nts_dynamo_1.DyNTS_App {
+    getAppParams() {
+        fsm_dynamo_1.DyFM_Log.testInfo(`FDP Agent Memory Server is up and running (ENV: ${process.env.FDP_ENV})`);
+        // DB-név: MONGODB_DB_NAME (dsgn-012 §7) vagy a build-time default.
+        const dbName = process.env.MONGODB_DB_NAME || 'fdp-agent-memory';
+        // Connection-string: MONGODB_URI (dsgn-012 §7) vagy a régi MONGO_URL, vagy lokális default.
+        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',
+            version: package_json_1.version,
+            dbName: dbName,
+            dbUri: `${mongoBase}/${dbName}`,
+            systemShortCodeName: 'FAM',
+        });
+    }
+    overrideDynamoNTSGlobalSettings() {
+        nts_dynamo_1.DyNTS_global_settings.log_settings.api_errors = false;
+        nts_dynamo_1.DyNTS_global_settings.log_settings.setup = true;
+        // NINCS JWT/auth check (ADR-004): a szerver lokális, single-user.
+    }
+    getGlobalServiceCollection() {
+        return {
+            // authService szándékosan KIMARAD (opcionális a DyNTS_GlobalService_Settings-ben) —
+            // nincs auth (ADR-004).
+            errorHandler: this.getGlobalErrorHandler(),
+            // A collection-lista SSOT-ja a `FAM_DB_MODELS` (`_collections/fam-db-models.const`) — ugyanazt
+            // regisztrálja az integration-test setup is (drift-mentes).
+            dbModels: fam_db_models_const_1.FAM_DB_MODELS,
+        };
+    }
+    getPortSettings() {
+        return {
+            httpPort: environment_1.env.httpPort,
+        };
+    }
+    getRoutingModules() {
+        return [
+            new nts_dynamo_1.DyNTS_RoutingModule({
+                route: '/server',
+                controllers: [
+                    server_status_controller_1.ServerStatus_Controller.getInstance(),
+                    errors_controller_1.Errors_Controller.getInstance(),
+                ],
+            }),
+            // MP-6 SP-6.5 — a CLI (MP-9) + UI (MP-10) közös REST-felülete: a 3 core-tool
+            // (read/write/capabilities) REST-tükre + items/stats/ingest-runs/config. A REST-handler
+            // UGYANAZT a transport-agnosztikus core-service-t hívja, mint az MCP-réteg (paritás).
+            // FONTOS (routing): a DyNTS `baseUrl='/api'`-t fűz minden routing-modul route elé, ezért az
+            // Api-modul route-ja `/` (NEM `/api`) → a végpontok `/api/read`, `/api/health`, … (a kliens
+            // `<origin>/api` + `/read`-et hív; dsgn-010 §9). A korábbi `/api` route `/api/api/*`-ot adott.
+            new nts_dynamo_1.DyNTS_RoutingModule({
+                route: '/',
+                controllers: [
+                    api_controller_1.Api_Controller.getInstance(),
+                ],
+            }),
+            // A beépített Angular admin-UI (`client-dist`): route `/app` → `baseUrl` elé fűzve → `/api/app`.
+            // EGY `fam start` (vagy a lokál Docker-image) a teljes felületet adja localhoston, külön
+            // kliens-process NÉLKÜL (dsgn-011 / dsgn-012; a `ccap-revisioned` `SC_ClientStatic` mintára).
+            new nts_dynamo_1.DyNTS_RoutingModule({
+                route: '/app',
+                controllers: [
+                    client_app_controller_1.ClientApp_Controller.getInstance(),
+                ],
+            }),
+            // NB: NINCS DyNTS_getTestRoutingModule / DyNTS_getUsageRoutingModule — a usage-controller
+            // `getAuthService()`-t hív (boot-crash a no-auth FAM-on, ADR-004), és egyik Dynamo-leftover
+            // route-ot sem használja a FAM (saját ServerStatus_Controller a health-re). FAM-REV-027.
+        ];
+    }
+    /**
+     * Post-setup hook (a DB-connect + setup UTÁN, dsgn-006 §4.1 / MP-2). Az embedding + Memory Vector
+     * Search boot-ja: (1) ENV → config seed (MP-7), (2) a `contentVector`-ok hidratálása a Mongo-ból az
+     * in-memory LVS pool-ba (BFR-AM-001 workaround). Best-effort: a hibák persistáltak (no-silent-failure),
+     * de a szerver-start NEM bukik el (a `read` bootstrap-skip-et jelez, amíg az embedding konfigurálódik).
+     *
+     * **Auto-embed-on-save:** NINCS globális embedding-service-regisztráció (a Dynamo `saveData` nem hív
+     * provider-agnosztikus embedding-hookot) — az embedding EXPLICIT a `FAM_EmbeddingPipeline_ControlService`-en
+     * á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() {
+        await embedding_1.FAM_EmbeddingBootstrap_ControlService.getInstance().boot();
+    }
+    getGlobalErrorHandler() {
+        return async (err, req, res, issuer) => {
+            // No-silent-failure (dsgn-008): minden hibát persistálunk a `fam_errors` tárba a
+            // FAM_Error_ControlService-en át (REUSE: DyNTS_Errors_DataService dedup + occurrence-count).
+            if (err?.___handled) {
+                fsm_dynamo_1.DyFM_Log.log('error already handled:', err?._message);
+                return;
+            }
+            let setIssuer = issuer ?? (req?.body)?.issuer;
+            setIssuer = setIssuer ?? err?.___issuerService ?? 'unknown-service';
+            await errors_control_service_1.FAM_Error_ControlService.globalErrorHandler(err, setIssuer);
+        };
+    }
+}
+exports.App = App;

package/build/src/environments/environment.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.env = void 0;
+const nts_dynamo_1 = require("@futdevpro/nts-dynamo");
+/**
+ * FDP Agent Memory server environment — Pure Dynamo, **AUTH NÉLKÜL** (ADR-004).
+ *
+ * Lokális, single-user MCP-szerver: NINCS JWT/bcrypt/auth. A `.env`-et a Dynamo
+ * env-loader olvassa `process.env`-be (dsgn-012 §7 — prod-kódban NINCS `dotenv` import;
+ * a `@futdevpro/nts-dynamo` `get-environment-settings.util` hívja a `dotenv.config()`-ot
+ * a `DyNTS_global_settings` betöltésekor).
+ */
+exports.env = {
+    env: process.env.FDP_ENV || nts_dynamo_1.DyNTS_global_settings.env_settings.environment,
+    // REST/UI szerver-port (NEM az MCP-stdio — az MVP1-ben stdio, dsgn-012 §4.1).
+    httpPort: +(process.env.FAM_SERVER_PORT || process.env.HTTP_PORT || 39185),
+    api: {
+    // Project-specifikus külső API kulcsok ide kerülnek (pl. embedding-provider, MP-6+).
+    },
+};

package/build/src/index.js

@@ -0,0 +1,18 @@
+#!/usr/bin/env node
+"use strict";
+//
+// FutDevPro FDP Agent Memory Server Side — entry / bin (`fam`).
+//
+Object.defineProperty(exports, "__esModule", { value: true });
+//
+// Indítás:
+//   node build/src/index.js start    → REST szerver (port 39185) + MCP stdio szerver (read/write/capabilities)
+//   node build/src/index.js          → CSAK REST szerver (visszafelé-kompatibilis; `new App()`)
+//   fam start                        → ugyanaz (a publikált bin a build/src/index.js-re mutat)
+//
+// stdio módban a stdout a JSON-RPC csatorna — minden log a stderr-re megy (dsgn-003 §1, dsgn-010 §6).
+//
+// For local run install MongoDB Community, and connect to the config.db_uri (uri in config file).
+//
+const fam_entry_bootstrap_util_1 = require("./_collections/fam-entry-bootstrap.util");
+void fam_entry_bootstrap_util_1.FAM_EntryBootstrap_Util.main(process.argv);