@futdevpro/nts-dynamo 1.15.118 → 1.15.120

package/src/_models/control-models/endpoint-params.control-model.ts

@@ -261,6 +261,18 @@ export class DyNTS_Endpoint_Params<
           return;
         }
 
+        // BFR-OVERSEER-010: a logResponseContent IMPLEMENTÁLVA (a korábbi "not implemented yet"
+        // warn-stub minden requestre spam-elt). A res.send-et wrap-eljük a küldött body
+        // elkapásához; a task-ok után csonkolt preview-t logolunk (log-flood ellen).
+        let capturedResponseBody: unknown;
+        if (this.logRequest && this.logResponseContent) {
+          const originalSend: Response['send'] = res.send.bind(res);
+          res.send = (body?: unknown): Response => {
+            capturedResponseBody = body;
+            return originalSend(body);
+          };
+        }
+
         await DyFM_Array.asyncForEach(this.tasks,
           async (
             task: (req: Request, res: Response, issuer?: string) => Promise<void>
@@ -268,13 +280,11 @@ export class DyNTS_Endpoint_Params<
             await task(req, res, issuer);
           }
         );
-  
+
         if (this.logRequest) {
+          DyFM_Log.success(`  <<<=====   '${this.name}' result sent.`);
           if (this.logResponseContent) {
-            DyFM_Log.success(`  <<<=====   '${this.name}' result sent.`);
-            DyFM_Log.warn('sorry, the logResponseContent is not implemented yet.');
-          } else {
-            DyFM_Log.success(`  <<<=====   '${this.name}' result sent.`);
+            DyFM_Log.info(`              response: ${DyNTS_Endpoint_Params.previewBody(capturedResponseBody)}`);
           }
         }
       } catch (error) {
@@ -283,6 +293,28 @@ export class DyNTS_Endpoint_Params<
     };
   }
 
+  /**
+   * BFR-OVERSEER-010: csonkolt, safe response-preview a logResponseContent-hez —
+   * nem-parseolható/circular body-ra nem dob, hosszú body-t levág (log-flood ellen).
+   */
+  private static previewBody(body: unknown): string {
+    const maxLength: number = 2000;
+    let text: string;
+    if (body === undefined) {
+      return '-no body captured-';
+    }
+    if (typeof body === 'string') {
+      text = body;
+    } else {
+      try {
+        text = JSON.stringify(body);
+      } catch {
+        text = String(body);
+      }
+    }
+    return text.length > maxLength ? `${text.slice(0, maxLength)}…(truncated ${text.length} chars)` : text;
+  }
+
   /**
    * 
    * @param res 
@@ -492,20 +524,16 @@ export class DyNTS_Endpoint_Params<
       // test/dev környezetben TELJES DyFM-leaket hagyott (__localStack + ___systemVersion + issuer).
       // A szabályok (mindig-strip / prod-only additionalContent / kliens-mezők megtartása) SSOT-ja
       // a DyNTS_ClientSafeError_Util.
-      res.send(DyNTS_ClientSafeError_Util.toClientSafe(error));
+      // BFR-OVERSEER-010: a kiküldött client-safe error megőrzése a logResponseContent-hez.
+      const clientSafeError: unknown = DyNTS_ClientSafeError_Util.toClientSafe(error);
+      res.send(clientSafeError);
 
       if (this.logRequest) {
+        DyFM_Log.error(
+          `  <<<=====   '${this.name}' error sent: ${(error as DyFM_Error)?._message ?? ''}`
+        );
         if (this.logResponseContent) {
-          DyFM_Log.error(
-            `  <<<=====   '${this.name}' error sent: ${(error as DyFM_Error)?._message ?? ''}`
-          );
-          DyFM_Log.error(
-            'sorry, the logResponseContent is not implemented yet.'
-          );
-        } else {
-          DyFM_Log.error(
-            `  <<<=====   '${this.name}' error sent: ${(error as DyFM_Error)?._message ?? ''}`
-          );
+          DyFM_Log.error(`              error response: ${DyNTS_Endpoint_Params.previewBody(clientSafeError)}`);
         }
       }
 

package/src/_models/data-models/schema-migration.data-model.ts

@@ -0,0 +1,50 @@
+import { DyFM_DataModel_Params, DyFM_Metadata } from '@futdevpro/fsm-dynamo';
+
+/**
+ * **Migráció-nyilvántartó ("server info") LEDGER** — bedrock, újrahasználható az egész flottának.
+ * (A token-service app-lokál `SchemaMigration` mintájából emelve bedrock nts-be.)
+ *
+ * Egy-egy `migrationId` **PONTOSAN EGYSZER** fut le rendszerenként: a `DyNTS_Migration_Runner.runPending()`
+ * boot-on (az app `app.server.postProcess()`-éből) lekéri a már-alkalmazott ID-kat, a pending
+ * migrációkat lefuttatja, majd egy sort rögzít ide. A `migrationId` **unique index** → race-safe
+ * (két párhuzamos instance esetén az egyik `save`-je duplicate-key-re bukik → skip).
+ *
+ * A ledger a KÖTELEZŐ kanon-adatokat tartja: **mely migrációk futottak** (id + idő) + **mely app-verzió**
+ * alkalmazta (a `appliedVersion`-ökből a "mely verziók futottak" levezethető).
+ *
+ * Az app a saját DB-jében regisztrálja a `dyNTS_schemaMigration_dataParams`-t (`getGlobalServiceCollection
+ * ().dbModels`), így per-app saját `dynts_schema_migrations` collection-t kap.
+ */
+export class DyNTS_SchemaMigration extends DyFM_Metadata {
+
+  /** A migráció egyedi azonosítója (konvenció: `YYYY-MM-DD-NNN-descriptor`). */
+  migrationId?: string;
+
+  /** Alkalmazás időbélyege. */
+  appliedAt?: Date;
+
+  /** Az alkalmazó app-verzió (a `package.json` version-je — audit-trail + "mely verziók futottak"). */
+  appliedVersion?: string;
+
+  /** Diag — pl. `touched=<n>` vagy hiba-részletek. */
+  notes?: string;
+
+  constructor(set?: DyNTS_SchemaMigration) {
+    super(set);
+    if (set) {
+      Object.assign(this, set);
+    }
+  }
+}
+
+export const dyNTS_schemaMigration_dataParams: DyFM_DataModel_Params<DyNTS_SchemaMigration> =
+  new DyFM_DataModel_Params<DyNTS_SchemaMigration>({
+    dataName: 'dynts_schema_migrations',
+    addArchive: false,
+    properties: {
+      migrationId:    { type: 'string', required: true, unique: true, index: true },
+      appliedAt:      { type: 'date',   required: true },
+      appliedVersion: { type: 'string' },
+      notes:          { type: 'string' },
+    },
+  });

package/src/_models/interfaces/migration-entry.interface.ts

@@ -0,0 +1,19 @@
+/**
+ * Egy regisztrált deploy-integrált migráció leírója. Az app egy `DyNTS_MigrationEntry[]` registry-t
+ * ad át a `DyNTS_Migration_Runner.runPending(...)`-nek; a runner a pending (még nem alkalmazott)
+ * entry-ket **egyszer** futtatja le, sorrendben, majd a `DyNTS_SchemaMigration` ledgerbe rögzíti.
+ */
+export interface DyNTS_MigrationEntry {
+  /** Egyedi, monoton bővíthető ID (konvenció: `YYYY-MM-DD-NNN-descriptor`). A ledger ez alapján run-once-ol. */
+  id: string;
+
+  /** Rövid leíró (admin/debug/log). */
+  description: string;
+
+  /**
+   * A tényleges migráció-logika. Az app már-csatlakozott Mongo-kapcsolatát használja (a runner a
+   * `postProcess`-ből fut, ahol a DB már él). Hibára DOBHAT — a runner catch-eli, a `notes`-ba menti,
+   * és NEM állítja meg a boot-ot. Visszaad: `{ touched }` (a módosított dokumentumok száma — count/riport).
+   */
+  run: (issuer: string) => Promise<{ touched: number }>;
+}

package/src/_modules/local-vector-search/_services/lvs-persistent-vector-pool.control-service.spec.ts

@@ -75,6 +75,22 @@ describe('| DyNTS_LVS_PersistentVectorPool_ControlService', () => {
       (collectionKey: string) =>
         Promise.resolve(Array.from(store.get(collectionKey)?.values() ?? [])),
     );
+
+    // BFR-AM-013 (hydration-paging): a batch-elt lean-scan fake-je — a fake-store tartalmát
+    // batch-enként adagolja a handler-nek (a valós cursor-viselkedés memóriában modellezve).
+    spyOn(DyNTS_LVS_VectorPersist_DataService.prototype, 'findLeanBatchedByCollectionKey').and.callFake(
+      async (
+        collectionKey: string,
+        set: { batchSize?: number; handler: (batch: Partial<DyNTS_LVS_VectorPersist>[]) => Promise<void> | void },
+      ): Promise<number> => {
+        const all: DyNTS_LVS_VectorPersist[] = Array.from(store.get(collectionKey)?.values() ?? []);
+        const batchSize: number = set.batchSize && set.batchSize > 0 ? set.batchSize : 500;
+        for (let i: number = 0; i < all.length; i += batchSize) {
+          await set.handler(all.slice(i, i + batchSize));
+        }
+        return all.length;
+      },
+    );
   });
 
   /** Egy egységvektor a tengely-irányba (cosine-self = 1) — determinisztikus keresés-ellenőrzéshez. */

package/src/_modules/local-vector-search/_services/lvs-persistent-vector-pool.control-service.ts

@@ -1,5 +1,5 @@
 
-import { DyFM_Log } from '@futdevpro/fsm-dynamo';
+import { DyFM_Error, DyFM_Log } from '@futdevpro/fsm-dynamo';
 
 import { LVS_Search_Mode } from '../_enums/lvs-search-mode.enum';
 import { LVS_SearchResult } from '../_models/lvs-search-result.interface';
@@ -97,24 +97,60 @@ export class DyNTS_LVS_PersistentVectorPool_ControlService {
    * előbb üríti (idempotens hidratálás). A hiányos (üres `vectorId`/`embedding`) rekordokat átugorja.
    * Visszaadja a betöltött vektorok számát. **NEM** Atlas — saját Mongo + in-memory pool.
    */
-  async hydrateFromMongo(): Promise<number> {
-    const records: DyNTS_LVS_VectorPersist[] =
-      await this.getPersistService().findByCollectionKey(this.collectionKey);
-
+  async hydrateFromMongo(set?: {
+    /** Cursor-batch méret (default 500) — a heap-tranziens felső korlátja egy batch. */
+    batchSize?: number,
+    /** Opcionális felső korlát a pool-méretre; elérésekor a hidratálás áll + WARN (no-silent-cap). */
+    maxVectors?: number,
+  }): Promise<number> {
+    // BFR-AM-013 (hydration-paging): a korábbi impl a TELJES collection-t egyetlen
+    // `findByCollectionKey`-jel (Mongoose-doc-tömb) töltötte memóriába → 32k×2560-dim vektornál
+    // RUNTIME-IGAZOLT 93% heap-spike (OOM-közeli). Mostantól LEAN + projektált (vectorId+embedding,
+    // a content-szöveg NÉLKÜL) CURSOR-batch — a tranziens felső korlátja EGY batch.
     this.pool.clearPool();
 
     let loaded: number = 0;
-
-    for (const record of records) {
-      if (!record.vectorId || !record.embedding?.length) {
-        continue;
-      }
-      this.pool.addVector(record.vectorId, record.embedding);
-      loaded++;
-    }
+    let skipped: number = 0;
+    let truncated: boolean = false;
+
+    await this.getPersistService().findLeanBatchedByCollectionKey(this.collectionKey, {
+      batchSize: set?.batchSize,
+      handler: (batch: Partial<DyNTS_LVS_VectorPersist>[]): void => {
+        for (const record of batch) {
+          if (truncated) {
+            return;
+          }
+          if (set?.maxVectors !== undefined && loaded >= set.maxVectors) {
+            truncated = true;
+            DyFM_Log.warn(
+              `[DyNTS LVS hydrate] '${this.collectionKey}': maxVectors (${set.maxVectors}) elérve — ` +
+              'a hidratálás CSONKOLVA (no-silent-cap; a maradék vektor NEM került a poolba).',
+            );
+            return;
+          }
+          if (!record.vectorId || !record.embedding?.length) {
+            continue;
+          }
+          try {
+            this.pool.addVector(record.vectorId, record.embedding);
+            loaded++;
+          } catch (error) {
+            // BFR-AM-013 (NaN/±Inf-guard a hidratálásban): EGY hibás (nem-véges elemű) perzistált
+            // vektor NEM boríthatja a teljes boot-hidratálást — skip + warn (nem néma).
+            skipped++;
+            DyFM_Log.warn(
+              `[DyNTS LVS hydrate] '${this.collectionKey}': vektor kihagyva ("${record.vectorId}") — ` +
+              `${DyFM_Error.getErrorMessage(error)}`,
+            );
+          }
+        }
+      },
+    });
 
     DyFM_Log.log(
-      `[DyNTS LVS hydrate] '${this.collectionKey}' pool: ${loaded} vektor betöltve az in-memory pool-ba.`,
+      `[DyNTS LVS hydrate] '${this.collectionKey}' pool: ${loaded} vektor betöltve az in-memory pool-ba` +
+      (skipped ? ` (${skipped} hibás vektor kihagyva)` : '') +
+      (truncated ? ' (CSONKOLT — maxVectors)' : '') + '.',
     );
 
     return loaded;

package/src/_modules/local-vector-search/_services/lvs-vector-persist.data-service.ts

@@ -48,6 +48,28 @@ export class DyNTS_LVS_VectorPersist_DataService extends DyNTS_DataService<DyNTS
     );
   }
 
+  /**
+   * BFR-AM-013 (hydration-paging): LEAN + projektált (CSAK `vectorId` + `embedding` — a content-szöveg
+   * és metadata NÉLKÜL) cursor-batch scan a boot-hidratáláshoz. A heap-tranziens felső korlátja EGY batch
+   * (a teljes result-set + Mongoose-doc-boxing kimarad). Soft-delete-elt rekordok kihagyva.
+   */
+  async findLeanBatchedByCollectionKey(
+    collectionKey: string,
+    set: {
+      batchSize?: number,
+      handler: (batch: Partial<DyNTS_LVS_VectorPersist>[]) => Promise<void> | void,
+    }
+  ): Promise<number> {
+    return this.dataDBService.findLeanBatched(
+      { collectionKey: collectionKey, _deleted: undefined },
+      {
+        projection: { vectorId: 1, embedding: 1 },
+        batchSize: set.batchSize,
+        handler: set.handler,
+      }
+    );
+  }
+
   /**
    * Egy vektor ATOMIKUS upsert-je a `(collectionKey, vectorId)` logikai-kulcson. MEGLÉVŐ rekordnál
    * `$set` (a Mixed `metadata` silent-drop ellen — memory: mongoose_mixed_atomic_write); ÚJ rekordnál

package/src/_modules/local-vector-search/_services/lvs-vector-pool.control-service.spec.ts

@@ -374,9 +374,11 @@ describe('| LVS_VectorPool_ControlService', () => {
       expect(vec1Result!.score).toBeCloseTo(1, 10);
     });
 
-    it('| should produce cosine scores IDENTICAL to static cosineSimilarity (precomputed-normalized perf optimization, BFR-AM-013)', () => {
+    it('| should produce cosine scores EQUIVALENT to static cosineSimilarity (precomputed-normalized + Float32 storage, BFR-AM-013)', () => {
       // Regression-guard: a search optimalizalt (precomputed-normalized + alloc-mentes) cosine-ja
-      // viselkedes-identikus a regi per-osszehasonlitas `cosineSimilarity(query, vector)`-ral.
+      // viselkedes-EKVIVALENS a regi per-osszehasonlitas `cosineSimilarity(query, vector)`-ral.
+      // Tolerancia 6 tizedes (nem 10): a pool BELSŐ tárolása Float32Array (BFR-AM-013 Tier-1,
+      // ~2-4× memória) → ~1e-7 kerekítési eltérés — a similarity-RANGSORT nem érinti.
       const query: number[] = [0.3, 0.7, 0.2];
       const results: LVS_SearchResult[] = vectorPool.search(query, 4, LVS_Search_Mode.cosineSimilarity);
 
@@ -386,7 +388,7 @@ describe('| LVS_VectorPool_ControlService', () => {
         const original: number[] | undefined = originals.get(result.id);
         expect(original).toBeDefined();
         const expected: number = LVS_VectorPool_ControlService.cosineSimilarity(query, original!);
-        expect(result.score).toBeCloseTo(expected, 10);
+        expect(result.score).toBeCloseTo(expected, 6);
       }
     });
 

package/src/_modules/local-vector-search/_services/lvs-vector-pool.control-service.ts

@@ -1,3 +1,5 @@
+import { DyFM_Log } from '@futdevpro/fsm-dynamo';
+
 import { LVS_Search_Mode } from '../_enums/lvs-search-mode.enum';
 import { LVS_SearchResult } from '../_models/lvs-search-result.interface';
 
@@ -10,14 +12,19 @@ export class LVS_VectorPool_ControlService {
   /**
    * In-memory vektor pool tárolás
    * Key: vektor ID, Value: vektor értékek
+   *
+   * BFR-AM-013 (Tier-1 memória): a belső tárolás `Float32Array` (4 byte/elem, boxing nélkül) a
+   * korábbi `number[]` (8 byte + array-boxing) helyett → ~2–4× kisebb PERSISTENS pool-footprint
+   * (2560-dim × 32k vektornál a heap érdemi része). A cosine/l2 index-alapú loopjai változatlanul
+   * futnak rajta; a publikus `getAll()` kontraktja (number[]) konverzióval megőrzött.
    */
-  private vectorPool: Map<string, number[]> = new Map<string, number[]>();
+  private vectorPool: Map<string, Float32Array> = new Map<string, Float32Array>();
 
   /**
    * Normalizált vektor pool tárolás (L2 normalizált másolatok)
-   * Key: vektor ID, Value: L2 normalizált vektor értékek
+   * Key: vektor ID, Value: L2 normalizált vektor értékek (Float32Array — l. fent)
    */
-  private normalizedVectorPool: Map<string, number[]> = new Map<string, number[]>();
+  private normalizedVectorPool: Map<string, Float32Array> = new Map<string, Float32Array>();
 
   /**
    * `normalizedOnly` mód: ha `true`, a pool NEM tárolja a nyers vektorokat (`vectorPool`) — CSAK a
@@ -52,13 +59,13 @@ export class LVS_VectorPool_ControlService {
     }
 
     // Tároljuk az eredeti vektort — KIVÉVE normalizedOnly módban (akkor a nyers pool kihagyva, ~50% memória).
+    // Float32Array-ként (BFR-AM-013 Tier-1) — a number[]-boxing nélkül.
     if (!this.normalizedOnly) {
-      this.vectorPool.set(id, vector);
+      this.vectorPool.set(id, Float32Array.from(vector));
     }
 
     // L2 normalizált másolatot is tárolunk a cosine similarity számításokhoz
-    const normalized: number[] = LVS_VectorPool_ControlService.l2Normalize(vector);
-    this.normalizedVectorPool.set(id, normalized);
+    this.normalizedVectorPool.set(id, LVS_VectorPool_ControlService.l2NormalizeFloat32(vector));
   }
 
   /**
@@ -102,7 +109,33 @@ export class LVS_VectorPool_ControlService {
    * Debugging és export céljára
    */
   getAll(): Map<string, number[]> {
-    return new Map<string, number[]>(this.vectorPool);
+    // A publikus kontrakt (number[]) megőrzése — a belső Float32Array-ből konvertálva.
+    const result: Map<string, number[]> = new Map<string, number[]>();
+    for (const [ id, vector ] of this.vectorPool.entries()) {
+      result.set(id, Array.from(vector));
+    }
+    return result;
+  }
+
+  /**
+   * BFR-AM-013 (Tier-1): L2-normalizálás Float32Array-be, explicit loopokkal (allokáció-minimális) —
+   * a pool BELSŐ tárolási formátumához. Nullvektor → csupa-0 Float32Array.
+   */
+  private static l2NormalizeFloat32(vector: ArrayLike<number>): Float32Array {
+    let sumSquares: number = 0;
+    for (let i: number = 0; i < vector.length; i++) {
+      sumSquares += vector[i] * vector[i];
+    }
+    const magnitude: number = Math.sqrt(sumSquares);
+
+    const normalized: Float32Array = new Float32Array(vector.length);
+    if (magnitude === 0) {
+      return normalized;
+    }
+    for (let i: number = 0; i < vector.length; i++) {
+      normalized[i] = vector[i] / magnitude;
+    }
+    return normalized;
   }
 
   /**
@@ -156,7 +189,7 @@ export class LVS_VectorPool_ControlService {
    * Eredmény: 0 vagy pozitív érték, ahol 0 a legkisebb távolság
    * Statikus metódus, mivel nincs szüksége instance state-re
    */
-  static l2Distance(a: number[], b: number[]): number {
+  static l2Distance(a: ArrayLike<number>, b: ArrayLike<number>): number {
     if (a.length !== b.length) {
       throw new Error(
         `Vectors must have the same dimension. Got ${a.length} and ${b.length}`
@@ -200,6 +233,14 @@ export class LVS_VectorPool_ControlService {
       throw new Error('Query vector must be a non-empty array');
     }
 
+    // BFR-AM-013 (NaN/±Inf-guard): nem-véges query-elem NÉMÁN mérgezné a TELJES rangsort
+    // (minden dot-product NaN → a valódi találatok kiesnek, hiba nélkül) → fail-closed throw.
+    for (let i: number = 0; i < query.length; i++) {
+      if (!Number.isFinite(query[i])) {
+        throw new Error(`Query vector must contain only finite numbers (non-finite at index ${i})`);
+      }
+    }
+
     if (k <= 0) {
       throw new Error('k must be a positive number');
     }
@@ -217,9 +258,9 @@ export class LVS_VectorPool_ControlService {
 
     // Validáljuk, hogy minden vektor ugyanolyan dimenziójú-e. A referencia-pool mód-függő: l2 a nyers,
     // cosine a normalizált (azonos dimenzió, de `normalizedOnly`-ban a nyers pool üres).
-    const referencePool: Map<string, number[]> =
+    const referencePool: Map<string, Float32Array> =
       mode === LVS_Search_Mode.l2Distance ? this.vectorPool : this.normalizedVectorPool;
-    const firstVector: number[] | undefined = Array.from(referencePool.values())[0];
+    const firstVector: Float32Array | undefined = referencePool.values().next().value;
     if (firstVector && firstVector.length !== query.length) {
       throw new Error(
         `Query vector dimension (${query.length}) does not match pool vector ` +
@@ -239,7 +280,10 @@ export class LVS_VectorPool_ControlService {
       //  (2) a per-összehasonlítás dot-product ALLOKÁCIÓ-MENTES (a régi `l2Normalize` hívásonként KÉT új
       //      tömböt allokált → egy 24k-vektoros keresés ~48k tömb-allokáció + GC-spike-ot okozott).
       // A drágán eltárolt `normalizedVectorPool` korábban SOHA nem volt használva a keresésben.
-      const queryNormalized: number[] = LVS_VectorPool_ControlService.l2Normalize(query);
+      const queryNormalized: Float32Array = LVS_VectorPool_ControlService.l2NormalizeFloat32(query);
+      // BFR-AM-013 (NaN-guard, defensive): ha egy tárolt vektor mégis NaN-score-t adna (elvileg az
+      // addVector-guard kizárja), a találat KIESIK — nem mérgezi a rangsort — és warn-t adunk (nem néma).
+      let nanScoreCount: number = 0;
       for (const [id, normalizedVector] of this.normalizedVectorPool.entries()) {
         if (candidateIds && !candidateIds.has(id)) {
           continue;
@@ -248,8 +292,15 @@ export class LVS_VectorPool_ControlService {
         for (let i: number = 0; i < queryNormalized.length; i++) {
           dotProduct += queryNormalized[i] * normalizedVector[i];
         }
+        if (!Number.isFinite(dotProduct)) {
+          nanScoreCount++;
+          continue;
+        }
         results.push({ id, score: dotProduct });
       }
+      if (nanScoreCount) {
+        DyFM_Log.warn(`[LVS search] ${nanScoreCount} vector(s) produced non-finite scores and were skipped.`);
+      }
       // Cosine similarity: csökkenő sorrend (legnagyobb hasonlóság először)
       results.sort((a: LVS_SearchResult, b: LVS_SearchResult) => b.score - a.score);
     } else if (mode === LVS_Search_Mode.l2Distance) {

package/src/_modules/server/server-status/server-status.control-service.ts

@@ -14,6 +14,8 @@ import * as mongoose from 'mongoose';
 
 import { version as _serverVersion } from '../../../../package.json';
 import { DyNTS_SingletonService } from '../../../_services/base/singleton.service';
+import { DyNTS_DbStats, DyNTS_DbStats_Util } from '../../../_services/core/db-stats.service';
+import { DyNTS_Diagnostics, DyNTS_DoctorReport } from '../../../_services/core/diagnostics.service';
 import { DyNTS_global_settings } from '../../../_collections/global-settings.const';
 import { DyNTS_Errors_ControlService } from '../errors/errors.control-service';
 import { DyNTS_ServerStatusSnapshot_ControlService } from './server-status-snapshot.control-service';
@@ -221,6 +223,16 @@ export abstract class DyNTS_ServerStatus_ControlService<
    * A mongoose default-connection. Külön metódus = teszt-seam (spy-jal felülírható, hogy a
    * {@link checkDbReadiness} DB nélkül is tesztelhető legyen).
    */
+  /** BFR-OVERSEER-004 — stats-only DB-diagnosztika a `/server/db-stats` endpointnak (metaadat-only). */
+  async getDbStats(): Promise<DyNTS_DbStats> {
+    return DyNTS_DbStats_Util.collect(this.getMongooseConnection());
+  }
+
+  /** BFR-AM-015 — aggregált doctor-riport a `/server/doctor` endpointnak (sosem dob). */
+  async runDoctor(): Promise<DyNTS_DoctorReport> {
+    return DyNTS_Diagnostics.runDoctor({ connection: this.getMongooseConnection() });
+  }
+
   protected getMongooseConnection(): mongoose.Connection {
     // FIX (2026-07-22) — a `mongoose.connection` NEM feltetlenul az a handle, amit a data-layer hasznal.
     //

package/src/_modules/server/server-status/server-status.controller.ts

@@ -252,6 +252,34 @@ export abstract class DyNTS_ServerStatus_Controller<
         ],
       }),
 
+      // BFR-OVERSEER-004 — stats-only DB-diagnosztika (per-collection count + méret + index-méret;
+      // metaadat-only, SOHA nem dokumentum-tartalom). App-auth-tal gate-elhető (lazyPreProcessesFor).
+      new DyNTS_Endpoint_Params({
+        name: 'getDbStats',
+        type: DyFM_HttpCallType.get,
+        endpoint: '/db-stats',
+        preProcesses: this.lazyPreProcessesFor('getDbStats'),
+        tasks: [
+          async (req: Request, res: Response): Promise<void> => {
+            res.send(await this.server_CS.getDbStats());
+          },
+        ],
+      }),
+
+      // BFR-AM-015 — aggregált doctor (mongo-probe + memory + event-loop + db-stats + app-checkek;
+      // health: ok|warn|fail + per-check fixHint). App-auth-tal gate-elhető.
+      new DyNTS_Endpoint_Params({
+        name: 'getDoctor',
+        type: DyFM_HttpCallType.get,
+        endpoint: '/doctor',
+        preProcesses: this.lazyPreProcessesFor('getDoctor'),
+        tasks: [
+          async (req: Request, res: Response): Promise<void> => {
+            res.send(await this.server_CS.runDoctor());
+          },
+        ],
+      }),
+
       // Readiness-probe: a /health-tel (liveness) szemben a DB-elérhetőséget is ellenőrzi.
       // Public (mint a /health) — orchestrátor/LB hívja; 503 ha a DB nem ready → no traffic.
       new DyNTS_Endpoint_Params({

package/src/_modules/socket/_models/socket-server-service-params.control-model.spec.ts

@@ -43,4 +43,27 @@ describe('| DyNTS_SocketServerService_Params', () => {
     expect(instance.port).toBeUndefined();
     expect(instance.security).toBe(DyNTS_SocketSecurity.open);
   });
+
+  // BFR-MASTERPROMPTER-025 — az attach-mód EXPLICIT opt-in, a port önmagában NEM diszkriminátor
+  it('| dedicatedPort default FALSE (shared) — port-label önmagában nem vált dedikáltra', () => {
+    const instance = new DyNTS_SocketServerService_Params({
+      name: 'LegacyPortLabel',
+      port: 39047,
+      security: DyNTS_SocketSecurity.open,
+    });
+
+    expect(instance.dedicatedPort).toBe(false);
+  });
+
+  it('| dedicatedPort: true explicit opt-in megőrződik', () => {
+    const instance = new DyNTS_SocketServerService_Params({
+      name: 'DedicatedNotif',
+      port: 39157,
+      dedicatedPort: true,
+      security: DyNTS_SocketSecurity.open,
+    });
+
+    expect(instance.dedicatedPort).toBe(true);
+    expect(instance.port).toBe(39157);
+  });
 });

package/src/_modules/socket/_models/socket-server-service-params.control-model.ts

@@ -4,12 +4,22 @@ import { DyNTS_SocketSecurity } from '../_enums/socket-security.enum';
 
 /**
  * Socket service paraméterek.
- * A port opcionális: ha nincs megadva, az app-extended a getPortSettings() httpPort/httpsPort értékét használja (ugyanaz a port, mint a HTTP/HTTPS).
+ *
+ * **BFR-MASTERPROMPTER-025 (attach-mód):** a socket alapból a fő HTTP/HTTPS szerverre attacholódik
+ * (SHARED — unified-port modell). Dedikált saját listener CSAK explicit `dedicatedPort: true`-val kérhető
+ * (+ `port` kötelező és ≠ fő port). A korábbi implicit inferencia (port≠httpPort → dedikált) csendben
+ * regresszálta azokat a unified-appokat, amelyek legacy-label okból adtak portot — ezért az attach-mód
+ * mostantól KÓD-EXPLICIT, a `port` önmagában NEM diszkriminátor.
  */
 export class DyNTS_SocketServerService_Params<T = any> {
   name: string;
   /** Opcionális: ha nincs megadva, az extended app a HTTP/HTTPS portot használja (same port). */
   port?: number;
+  /**
+   * EXPLICIT opt-in a dedikált saját listenerre (a fő szerver HELYETT). Default: false = shared.
+   * `true` esetén a `port` kötelező és el kell térnie a fő HTTP-porttól.
+   */
+  dedicatedPort?: boolean;
   security?: DyNTS_SocketSecurity;
 
   constructor(
@@ -17,6 +27,7 @@ export class DyNTS_SocketServerService_Params<T = any> {
   ) {
     this.name = set.name;
     this.port = set.port;
+    this.dedicatedPort = set.dedicatedPort ?? false;
     this.security = set.security ? set.security : DyNTS_global_settings.defaultSocketSecurity;
   }
 }

package/src/_modules/socket/_services/socket-server.service.ts

@@ -51,6 +51,8 @@ export abstract class DyNTS_SocketServerService<
   protected params: DyNTS_SocketServerService_Params;
   get name(): string { return this.params.name; }
   get port(): number | undefined { return this.params.port; }
+  /** BFR-MASTERPROMPTER-025: explicit dedikált-listener opt-in (default false = shared). */
+  get dedicatedPort(): boolean { return this.params.dedicatedPort ?? false; }
   get security(): DyNTS_SocketSecurity { return this.params.security; }
   get activeSubscriptionsCount(): number { return this.presences.length; }
 

package/src/_modules/socket/app-extended.server.ts

@@ -512,15 +512,21 @@ export abstract class DyNTS_AppExtended extends DyNTS_App {
             if (service.security === DyNTS_SocketSecurity.open) {
               this.systemControlsExt.httpSocketServer.init = true;
 
-              // BFR-FDPTOKENSERVICE-007 (fleet-wide realtime 502): ha a service SAJÁT (dedikált) portot
-              // kér, ami ELTÉR a fő HTTP-porttól, a socket a SAJÁT portjára listen-el — NEM a fő szerverre
-              // attacholódik. Enélkül base-server mellett a dedikált notif-port SOSEM kap listenert (a
-              // socket a fő portra attacholt) → a gateway a notif-porton 502-t ad. A fő-portot MEGOSZTÓ
-              // socket (port nincs, v. == httpPort) viselkedése VÁLTOZATLAN. A dedikált-ág a már bizonyított
-              // non-base útvonalat tükrözi (saját Http.Server + listen).
-              const sharesMainHttpPort: boolean =
-                service.port === undefined || service.port === this.portSettings.httpPort;
-              const attachToMain: boolean = useBaseHttpServer && sharesMainHttpPort;
+              // BFR-MASTERPROMPTER-025 (a BFR-FDPTOKENSERVICE-007 3a2c381 utó-fix-e): az attach-mód
+              // EXPLICIT opt-in (`dedicatedPort: true`), NEM a port-érték implicit inferenciája. A
+              // korábbi `port≠httpPort → dedikált` inferencia CSENDBEN regresszálta a unified-shared
+              // appokat, amelyek legacy-label/notif-konvenció okból adtak portot (MP live-igazolt:
+              // realtime DEAD az nts-bump után; adventor/ccap/warbots latens). Mostantól:
+              //   - default (dedicatedPort hiányzik/false) → SHARED (a fő szerverre attach, a port-label irreleváns);
+              //   - dedicatedPort: true → saját Http.Server + listen a service.port-on (a bizonyított
+              //     non-base útvonal tükre) — pl. a token-service szándékosan-dedikált notif-portja.
+              if (service.dedicatedPort && (service.port === undefined || service.port === this.portSettings.httpPort)) {
+                throw new Error(
+                  `SOCKET CONFIG ERROR: "${service.name}" dedicatedPort:true requires an explicit ` +
+                  `port that differs from the main httpPort (${this.portSettings.httpPort}).`
+                );
+              }
+              const attachToMain: boolean = useBaseHttpServer && !service.dedicatedPort;
               const serverForOpen: Http.Server = attachToMain
                 ? this.httpServer
                 : (useBaseHttpServer