@futdevpro/fdp-agent-memory 1.1.14 → 1.1.21

package/build/package.json

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

package/build/src/_cli/_commands/config.command.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FAM_Config_Util = void 0;
 const commander_1 = require("commander");
+const fam_config_value_coerce_util_1 = require("../../_collections/fam-config-value-coerce.util");
 const fam_output_util_1 = require("../_collections/fam-output.util");
 const fam_client_service_1 = require("../_services/fam-client.service");
 const fam_cli_const_1 = require("../_collections/fam-cli.const");
@@ -67,9 +68,11 @@ class FAM_Config_Util {
     static async runSet(command) {
         const globals = command.optsWithGlobals();
         const local = command.opts();
+        // A CLI `--value` mindig string; a szerver típus-szigorúan validál → a katalógus-típusra konvertáljuk
+        // (boolean/number/string[] kulcsok így CLI-ből is állíthatók — FAM_ConfigValueCoerce_Util).
         const body = {
             key: local.key,
-            value: local.value,
+            value: fam_config_value_coerce_util_1.FAM_ConfigValueCoerce_Util.coerce(local.key, local.value),
             table: local.table,
             scopeId: local.scope,
         };

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

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.FAM_ScanProjects_Util = void 0;
 const fs_1 = require("fs");
 const commander_1 = require("commander");
+const fam_cooldown_util_1 = require("../../_collections/fam-cooldown.util");
 const fam_output_util_1 = require("../_collections/fam-output.util");
 const fam_client_service_1 = require("../_services/fam-client.service");
 const fam_cli_const_1 = require("../_collections/fam-cli.const");
@@ -26,6 +27,8 @@ class FAM_ScanProjects_Util {
             .option('--org <name>', 'default organization az auto-felderítéshez', 'FutDevPro')
             .option('--table <documents|codebase>', 'default cél-tár', 'codebase')
             .option('--dry-run', 'csak becslés MINDEN projektre, NEM ír', false)
+            .option('--cooldown <ms>', 'cooldown a projektek KÖZÉ (ms) — gép-tehermentesítő szünet nagy multi-scanhez; '
+            + 'felülírja a `scan.projectCooldownMs` configot (default: a config, ami 0 = ki)')
             .option('--stop-on-error', 'az első hibánál leáll (default: folytatja a többivel)', false)
             .addHelpText('before', '\n⚠️  TISZTA MULTI-SCAN — ELŐBB minden projektbe IGNORE-FÁJL:\n'
             + '   Mivel ez TÖBB projektet szkennel egyszerre, a junk gyorsan elszaporodik. MINDEN érintett\n'
@@ -77,7 +80,11 @@ class FAM_ScanProjects_Util {
         const client = new fam_client_service_1.FAM_CliClient_Service(globals.serverUrl);
         const projects = [];
         let okCount = 0;
-        FAM_ScanProjects_Util.progress(globals, `=== ${specs.length} projekt SOROS scan-je${local.dryRun ? ' (dryRun)' : ''} ===`);
+        // Projekt-cooldown (user-FR): a `--cooldown <ms>` felülírja a szerver `scan.projectCooldownMs` configját
+        // (default 0 = ki). dryRun-on nincs cooldown (nincs valódi embed-munka). A projektek KÖZÉ vár, nem az utolsó után.
+        const projectCooldownMs = local.dryRun ? 0 : await FAM_ScanProjects_Util.resolveCooldownMs(client, local.cooldown);
+        FAM_ScanProjects_Util.progress(globals, `=== ${specs.length} projekt SOROS scan-je${local.dryRun ? ' (dryRun)' : ''}`
+            + `${projectCooldownMs > 0 ? `, cooldown ${projectCooldownMs}ms/projekt` : ''} ===`);
         for (let i = 0; i < specs.length; i++) {
             const spec = specs[i];
             FAM_ScanProjects_Util.progress(globals, `[${i + 1}/${specs.length}] ${spec.project} (${spec.path})`);
@@ -109,6 +116,11 @@ class FAM_ScanProjects_Util {
                     break;
                 }
             }
+            // Projekt-cooldown: a projektek KÖZÉ (NEM az utolsó után) — gép-tehermentesítő szünet nagy multi-scanhez.
+            if (projectCooldownMs > 0 && i < specs.length - 1) {
+                FAM_ScanProjects_Util.progress(globals, `  cooldown ${projectCooldownMs}ms…`);
+                await fam_cooldown_util_1.FAM_Cooldown_Util.sleep(projectCooldownMs);
+            }
         }
         FAM_ScanProjects_Util.progress(globals, `=== KÉSZ: ${okCount}/${specs.length} ok ===`);
         return fam_output_util_1.FAM_Output_Util.success({
@@ -116,6 +128,19 @@ class FAM_ScanProjects_Util {
             data: { total: specs.length, ok: okCount, projects: projects },
         });
     }
+    /**
+     * A projekt-cooldown ms feloldása: a CLI `--cooldown` felülírja a szerver `scan.projectCooldownMs` configját.
+     * Nincs CLI-érték → a szerver effektív configját kérdezi (`GET /api/config`); a config-lekérés hibája → 0 (a
+     * cooldown sosem buktatja a scant). Minden út a `FAM_Cooldown_Util.resolveMs`-en megy át (clamp + biztonság).
+     */
+    static async resolveCooldownMs(client, cliValue) {
+        if (cliValue !== undefined) {
+            return fam_cooldown_util_1.FAM_Cooldown_Util.resolveMs(cliValue);
+        }
+        const result = await client.get('/api/config');
+        const value = result.ok ? result.data?.effective?.['scan.projectCooldownMs'] : 0;
+        return fam_cooldown_util_1.FAM_Cooldown_Util.resolveMs(value);
+    }
     /** A scan-request body egy projekt-spec-hez (dryRun vagy valós). */
     static body(spec, dryRun, defaults) {
         return {

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

@@ -205,12 +205,42 @@ exports.CONFIG_CATALOG = {
         type: 'boolean', default: false, levels: ALL_LEVELS,
         description: 'Symlink-követés (path-traversal védelem, dsgn-004).',
     },
+    'scan.nestedFamignore': {
+        type: 'boolean', default: true, levels: ALL_LEVELS,
+        description: 'A NESTED (per-alkönyvtár) `.fdpfamignore`-ok figyelembevétele a bejárás közben. `true` (default) '
+            + '= ha egy al-projektben/al-mappában van saját `.fdpfamignore`, azt is betöltjük (a saját al-útjához '
+            + 'horgonyozva) és alkalmazzuk arra a subtree-re — így a teljes-workspace scan tiszteletben tartja az '
+            + 'al-projektek saját ignore-jait (eleve-tisztán-szkennelés). `false` = csak a scan-GYÖKÉR `.fdpfamignore`-ja '
+            + 'érvényes (a régi, v1-viselkedés — ha valaki kizárólag gyökér-szintű kontrollt akar).',
+    },
+    'scan.reconcileIgnored': {
+        type: 'boolean', default: true, levels: ALL_LEVELS,
+        description: 'Re-scankor a MOST ignore-minta által kizárt (de korábban beolvasott) fájlok meglévő chunkjainak '
+            + 'kitakarítása a tárból. `true` (default — TISZTOGATÁS) = ha utólag hozzáadsz egy ignore-/famignore-mintát, '
+            + 'a re-scan az így kizárttá vált fájlok régi bejegyzéseit orphanként soft-delete-eli (nem ragad be, amit '
+            + 'ignore-olni akarsz). `false` = a régi viselkedés (az ignore-skippelt fájl „jelen-lévőként" számít, a régi '
+            + 'chunkjai BENT MARADNAK — ha valaki a korábbi beolvasást meg akarja őrizni). A lemezről ELTŰNT fájlokat '
+            + 'mindkét beállítás reconciliálja (ez attól független).',
+    },
     'scan.testFileWeight': {
         type: 'number', default: 0.5, min: 0.0, max: 10.0, levels: ALL_LEVELS,
         description: 'A teszt-/spec-fájlok (`*.spec.*` / `*.test.*`) DEFAULT retrieval-súlya (FAM-REV-058) — a próza-'
             + 'nehéz specek különben az IMPLEMENTÁCIÓ fölé rangsorolnak. <1 → a forrás alá; explicit scan-`weights` '
             + 'felülírja; 1 = nincs csökkentés.',
     },
+    'scan.sectionCooldownMs': {
+        type: 'number', default: 0, min: 0, max: 60000, integer: true, levels: ALL_LEVELS,
+        description: 'Kikapcsolható cooldown (ms) a SZEKCIÓK (file-batch-ek) KÖZÉ egy scanen belül — a NAGY DB-k '
+            + 'beolvasásakor ad lélegzetvételi szünetet a gépnek (CPU/embed-provider/Mongo ne terhelődjön túl). '
+            + 'Default `0` = KIKAPCSOLVA (nincs lassítás); nagy scanre állítsd pl. 1000–3000-re. Csak a batch-ek '
+            + 'KÖZÖTT vár (az utolsó után nem), és a `dryRun` NEM vár (nincs valódi embed-munka).',
+    },
+    'scan.projectCooldownMs': {
+        type: 'number', default: 0, min: 0, max: 60000, integer: true, levels: ALL_LEVELS,
+        description: 'Kikapcsolható cooldown (ms) a PROJEKTEK KÖZÉ a `scan-projects` soros multi-scan-jében — a sok-'
+            + 'projektes (L2/L6) beolvasás ne thrash-elje a gépet. Default `0` = KIKAPCSOLVA; nagy futásra pl. 2000–'
+            + '5000. A CLI `--cooldown <ms>` felülírja ezt a config-default-ot (a projektek KÖZÖTT vár, az utolsó után nem).',
+    },
     'scan.estimateMsPerChunk': {
         type: 'number', default: 250, min: 1, max: 10000, integer: true, levels: ALL_LEVELS,
         description: 'A `dryRun` pre-scan idő-becsléshez: becsült embed-idő chunkonként (ms). DURVA, gép-/modell-/'
@@ -239,6 +269,32 @@ 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.',
+    },
     '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/fam-config-value-coerce.util.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FAM_ConfigValueCoerce_Util = void 0;
+const config_catalog_const_1 = require("./config-catalog.const");
+/**
+ * `FAM_ConfigValueCoerce_Util` — a `config set` CLI nyers `--value` STRING-jét a katalógus-kulcs típusára konvertálja
+ * (a CLI argumentum mindig string, a szerver viszont típus-szigorúan validál — boolean/number kulcsot string-ként
+ * elutasít: `FAM-CONFIG-SET-002`). Ez teszi a config-kapcsolókat (pl. `scan.nestedFamignore` / `scan.reconcileIgnored`
+ * / `scan.followSymlinks`) ténylegesen CLI-ből állíthatóvá. A `CONFIG_CATALOG[key].type` alapján:
+ *
+ * - `boolean` → `'true'`/`'false'` → bool (más → változatlan string, hogy a szerver adjon egyértelmű hibát);
+ * - `number` → `Number(raw)` (NaN → változatlan string);
+ * - `number-or-null` → `'null'`/üres → `null`, különben `Number(raw)`;
+ * - `string[]` → JSON-tömb (`[...]`) VAGY vesszős lista → `string[]`;
+ * - `string` (+ enum) → változatlan.
+ *
+ * Ismeretlen kulcs → változatlan string (a szerver `FAM-CONFIG-SET-001`-gyel utasítja el). Tisztán pure.
+ */
+class FAM_ConfigValueCoerce_Util {
+    /** A nyers CLI-string → a `key` katalógus-típusának megfelelő JS-érték (lásd az osztály-leírást). */
+    static coerce(key, raw) {
+        const entry = config_catalog_const_1.CONFIG_CATALOG[key];
+        if (!entry) {
+            return raw;
+        }
+        switch (entry.type) {
+            case 'boolean':
+                if (raw === 'true') {
+                    return true;
+                }
+                if (raw === 'false') {
+                    return false;
+                }
+                return raw;
+            case 'number': {
+                const value = Number(raw);
+                return Number.isNaN(value) ? raw : value;
+            }
+            case 'number-or-null': {
+                if (raw === 'null' || raw === '') {
+                    return null;
+                }
+                const value = Number(raw);
+                return Number.isNaN(value) ? raw : value;
+            }
+            case 'string[]': {
+                const trimmed = raw.trim();
+                if (trimmed.startsWith('[')) {
+                    try {
+                        return JSON.parse(trimmed);
+                    }
+                    catch {
+                        // nem valid JSON → essünk át a vesszős listára
+                    }
+                }
+                return trimmed.length ? trimmed.split(',').map((item) => item.trim()).filter(Boolean) : [];
+            }
+            default:
+                return raw;
+        }
+    }
+}
+exports.FAM_ConfigValueCoerce_Util = FAM_ConfigValueCoerce_Util;

package/build/src/_collections/fam-cooldown.util.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FAM_Cooldown_Util = void 0;
+/**
+ * `FAM_Cooldown_Util` (user-FR 2026-06-21) — opcionális, **kikapcsolható** cooldown (lélegzetvételi szünet) a
+ * scan-feldolgozás közé, hogy a NAGY adatbázisok beolvasása NE terhelje túl a gépet (CPU/embed-provider/Mongo).
+ * Két ponton fogyasztva: (a) a SZEKCIÓK (file-batch-ek) között egy scanen belül (`scan.sectionCooldownMs`, szerver-
+ * oldali ingest-loop); (b) a PROJEKTEK között a `scan-projects` soros orchestrátorban (`scan.projectCooldownMs` /
+ * CLI `--cooldown`). Default **0 = kikapcsolva** (nincs lassítás) → opt-in: a user nagy scanre bekapcsolja.
+ *
+ * Tisztán: a `resolveMs` (parse + clamp) pure + külön tesztelhető; a `sleep` az egyetlen side-effect.
+ */
+class FAM_Cooldown_Util {
+    /** Biztonsági felső korlát egy cooldown-ra (ms) — egy elgépelt óriás-érték ne fagyassza be a scant. */
+    static MAX_MS = 60000;
+    /**
+     * Nyers config/CLI érték → biztonságos cooldown ms. Nem-szám / NaN / ≤0 → `0` (kikapcsolva); egyébként egész
+     * ms-re vágva, `[0, MAX_MS]`-re clamp-elve. Így a hibás/extrém input sosem buktatja vagy fagyasztja a scant.
+     */
+    static resolveMs(raw) {
+        const value = typeof raw === 'number' ? raw : Number(raw);
+        if (!Number.isFinite(value) || value <= 0) {
+            return 0;
+        }
+        return Math.min(Math.floor(value), FAM_Cooldown_Util.MAX_MS);
+    }
+    /** Vár `ms` ideig (≤0 → azonnal visszatér, nincs timer). A cooldown egyetlen tényleges késleltetése. */
+    static async sleep(ms) {
+        if (ms <= 0) {
+            return;
+        }
+        await new Promise((resolve) => setTimeout(resolve, ms));
+    }
+}
+exports.FAM_Cooldown_Util = FAM_Cooldown_Util;

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

@@ -0,0 +1,176 @@
+"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;

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

@@ -0,0 +1,31 @@
+"use strict";
+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/ingest/_collections/fam-famignore.util.js

@@ -4,6 +4,7 @@ exports.FAM_FamIgnore_Util = void 0;
 const tslib_1 = require("tslib");
 const fs = tslib_1.__importStar(require("fs"));
 const path = tslib_1.__importStar(require("path"));
+const fam_glob_match_util_1 = require("./fam-glob-match.util");
 /**
  * `FAM_FamIgnore_Util` (descriptive user feedback / nagy-scan ergonómia) — a **`.fdpfamignore`** in-repo,
  * gitignore-stílusú ignore-fájl támogatása. A projekt (vagy a workspace-gyökér) MAGÁBAN hordozza, mit hagyjon
@@ -13,7 +14,10 @@ const path = tslib_1.__importStar(require("path"));
  * **Szintaxis (gitignore-szerű, a `FAM_GlobMatch_Util`-ra fordítva):** soronként egy minta; `#` komment + üres
  * sor kihagyva. `node_modules` (csupasz név) → bárhol illeszkedik; `/build` (vezető `/`) → a gyökérhez horgonyzott;
  * `dist/` (záró `/`) → könyvtár; `src/gen` (beágyazott `/`) → gyökér-relatív; `*.tgz` → bárhol. **A `!` negáció
- * v1-ben NEM támogatott** (a flat „matchesAny → skip" modellben — BACKLOG), az ilyen sorok kihagyva.
+ * (re-include) TÁMOGATOTT** (user-FR 2026-06-21): `parse` az ignore-sorokat, `parseNegations` a `!`-sorokat adja;
+ * a fogyasztó (scan) a fájlt akkor SKIP-eli, ha ignore-match ÉS NEM re-include-match — a könyvtár-prune pedig
+ * `dirOnReincludeLineage`-tudatos (egy ignore-olt mappát NEM vág le, ha re-included elem van rajta/alatta). Így
+ * a „ignore-mindent-kivéve-X" (pl. `ccap/` + `!ccap/client/`) helyesen működik a rekurzív bejárásban is.
  *
  * **v1 hatókör:** a scan-GYÖKÉR `.fdpfamignore`-ja (a teljes scanre). A NESTED (per-alkönyvtár) `.fdpfamignore`
  * a két-fázisú felderítés (walk → classify) miatt külön kör — BACKLOG (a `baseDir` paraméter már készen áll rá).
@@ -62,9 +66,61 @@ class FAM_FamIgnore_Util {
         }
         return patterns;
     }
+    /**
+     * A `!`-negáció (**re-include**) sorai — a vezető `!` levágva. Tisztán pure (a fordítás külön). Az `ignore`
+     * (`parse`) + a re-include (`parseNegations`) együtt adja a gitignore-szerű „ignore-mindent-kivéve" szemantikát.
+     */
+    static parseNegations(content) {
+        const result = [];
+        for (const rawLine of content.split(/\r?\n/)) {
+            const line = rawLine.trim();
+            if (line.startsWith('!') && line.length > 1) {
+                result.push(line.slice(1).trim());
+            }
+        }
+        return result;
+    }
+    /**
+     * A re-include (`!`) szabályok egy könyvtárból: **`globs`** (a fájl-szintű re-include-matchhez, `<base>` +
+     * `<base>/**`) + **`bases`** (a `/**` nélküli alap-utak — a KÖNYVTÁR-prune lineage-ellenőrzéséhez: egy ignore-olt
+     * könyvtárat NEM vágunk le, ha egy re-include alatta/fölötte/rajta van). Hiányzó fájl → üres. Fail-safe.
+     */
+    static loadReincludeRules(dirAbsolutePath, baseDir = '') {
+        try {
+            const filePath = path.join(dirAbsolutePath, FAM_FamIgnore_Util.FILENAME);
+            if (!fs.existsSync(filePath)) {
+                return { globs: [], bases: [] };
+            }
+            const negations = FAM_FamIgnore_Util.parseNegations(fs.readFileSync(filePath, 'utf-8'));
+            const globs = FAM_FamIgnore_Util.toGlobPatterns(negations, baseDir);
+            const bases = [...new Set(globs.map((glob) => glob.replace(/\/\*\*$/, '')))];
+            return { globs: globs, bases: bases };
+        }
+        catch {
+            return { globs: [], bases: [] };
+        }
+    }
+    /**
+     * `true`, ha a `dir` (root-relatív út) NEM prune-olható egy re-include miatt: (1) maga a dir re-included (vagy
+     * egy re-included alfa alatt van) — ezt **glob-match**-csel ellenőrizzük a re-include-`globs` ellen (így a
+     * `(glob)/client` minta a `client` dir-re, a `(glob)/client/(glob)` a `client/src` dir-re is illeszkedik); VAGY
+     * (2) a dir egy **anchored** (glob-mentes) re-include base ŐSE (van alatta re-included elem) — ezt string-prefixszel.
+     * (A bare-bázisok ős-esetét az (1) fedi.) Ez teszi a negációt traversal-helyessé (a szülőt nem vágjuk le idő előtt).
+     */
+    static dirOnReincludeLineage(dir, reincludeGlobs, reincludeBases) {
+        const d = dir.replace(/\\/g, '/').replace(/\/+$/, '');
+        if (fam_glob_match_util_1.FAM_GlobMatch_Util.matchesAny(d, reincludeGlobs)) {
+            return true;
+        }
+        return reincludeBases.some((rawBase) => {
+            const base = rawBase.replace(/\/+$/, '');
+            return !base.includes('*') && base.startsWith(`${d}/`);
+        });
+    }
     /**
      * A `.fdpfamignore` beolvasása + fordítása egy könyvtárból (a `dirAbsolutePath`-ban). Hiányzó / olvashatatlan
      * fájl → `[]` (opt-in: csak ha létezik). A `baseDir` a root-relatív horgony (a gyökér-szintű hívásnál `''`).
+     * (Csak az IGNORE minták — a re-include-ot a `loadReincludeRules` adja.)
      */
     static loadFromDir(dirAbsolutePath, baseDir = '') {
         try {

package/build/src/_modules/ingest/_collections/fam-scan-reconcile.util.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FAM_ScanReconcile_Util = void 0;
+/**
+ * `FAM_ScanReconcile_Util` (user-FR 2026-06-21) — a re-scan **whole-file orphan reconciliation** present-set
+ * számítása. A „present" halmaz az a fájl-útvonal-készlet, amit a friss scan a lemezen MEGTALÁLT (és ezért a
+ * táron meglévő, e halmazon KÍVÜLI `scan`-entry-k orphanok → soft-delete). A finomság a **most ignore-mintával
+ * kizárt** fájlok kezelése (`scan.reconcileIgnored`):
+ *
+ * - **`reconcileIgnored = true` (default — TISZTOGATÁS):** az ignore-minta által skippelt fájl NEM számít
+ *   present-nek → a korábban beolvasott, de most ignore-olttá vált fájl régi chunkjai orphanként kitakaríthatók
+ *   (ne ragadjon be, amit ignore-olni akarunk). A többi skip-ok (secret / méret / unrouted / include-filter) MARAD
+ *   present (a fájl a lemezen van, csak most nem ingesteljük — NEM töröljük a régi tudást).
+ * - **`reconcileIgnored = false` (régi viselkedés):** MINDEN skippelt fájl present → a régi chunkok megmaradnak.
+ *
+ * A lemezről ELTŰNT fájlok mindkét módban orphanok (eleve nincsenek a routed/skipped halmazban) — ez a beállítástól
+ * független. Tisztán pure (Set-számítás), külön tesztelhető; a `reconcileDeletedFiles` ezt hívja.
+ */
+class FAM_ScanReconcile_Util {
+    /**
+     * A friss scan present-path halmaza (abszolút utak). A `routedFiles` mind present; a `skippedFiles` present,
+     * KIVÉVE az ignore-minta-kizártakat (`excludedByIgnore`), ha `reconcileIgnored` — azok orphanná válnak, hogy a
+     * régi chunkjaik kitakaríthatók legyenek. Üres input → üres halmaz.
+     */
+    static computePresentPaths(routedFiles, skippedFiles, reconcileIgnored) {
+        const present = new Set();
+        for (const routed of routedFiles) {
+            present.add(routed.absolutePath);
+        }
+        for (const skipped of skippedFiles) {
+            // A most ignore-mintával kizárt fájl NEM present (ha tisztogatunk) → a régi bejegyzése orphan → törölhető.
+            if (reconcileIgnored && skipped.excludedByIgnore) {
+                continue;
+            }
+            present.add(skipped.absolutePath);
+        }
+        return present;
+    }
+}
+exports.FAM_ScanReconcile_Util = FAM_ScanReconcile_Util;

package/build/src/_modules/ingest/_collections/fam-secret-content.util.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FAM_SecretContent_Util = void 0;
+/**
+ * `FAM_SecretContent_Util` (user-FR 2026-06-21) — **tartalmi** (fájlon-BELÜLi) secret-redakció. A `FAM_SecretExclude_Util`
+ * csak fájlNÉV-alapú (a `.env`/`*.key` típusú titok-FÁJLOKAT zárja ki); de egy `.ts`/`.py` FORRÁSBA hardcode-olt
+ * API-kulcs (pl. `apiKey: 'sk-…'`) eddig beolvasódott a vektor-tárba (élő lelet 2026-06-21: 1 OpenAI-kulcs 4 config-
+ * fájlban). Ez a util a fájl-tartalmat OLVASÁSKOR redaktálja (a chunk/contentHash/embedding/tárolt szöveg MIND a
+ * redaktált változatot kapja) → a titok soha nem kerül a DB-be, és egy korábban-szivárgott fájl RE-SCANKOR
+ * auto-gyógyul (a contentHash változik a redakciótól → `modified` → a tárolt content felülíródik).
+ *
+ * **Magas-konfidenciájú, jellegzetes alakú token-minták** (alacsony false-positive): OpenAI `sk-…`, AWS `AKIA…`,
+ * GitHub `ghp_/gho_…`, Google `AIza…`, Slack `xox.-…`, privát-kulcs PEM-blokk, JWT. NEM próbál generikus
+ * `password=…`-t fogni (az túl sok forrás-konstanst redaktálna) — a cél a VALÓDI kulcs-szivárgás, nem a kód-RAG rontása.
+ */
+class FAM_SecretContent_Util {
+    /** A redaktált tokenek helyére kerülő jelölő (a kód-kontextus megmarad, csak a titok tűnik el). */
+    static PLACEHOLDER = '***REDACTED-SECRET***';
+    /** Magas-konfidenciájú secret-token minták (jellegzetes prefix + hossz → kevés false-positive). */
+    static PATTERNS = [
+        { name: 'openai', re: /sk-(?:proj-)?[A-Za-z0-9_-]{32,}/g },
+        { name: 'aws-access-key', re: /\bAKIA[0-9A-Z]{16}\b/g },
+        { name: 'github-token', re: /\bgh[posur]_[A-Za-z0-9]{36,}\b/g },
+        { name: 'google-api', re: /\bAIza[0-9A-Za-z_-]{35}\b/g },
+        { name: 'slack-token', re: /\bxox[baprs]-[A-Za-z0-9-]{10,}\b/g },
+        { name: 'private-key-block', re: /-----BEGIN (?:RSA |EC |OPENSSH |DSA |PGP )?PRIVATE KEY-----[\s\S]*?-----END (?:RSA |EC |OPENSSH |DSA |PGP )?PRIVATE KEY-----/g },
+        { name: 'jwt', re: /\beyJ[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{6,}\b/g },
+    ];
+    /**
+     * A `text` magas-konfidenciájú secret-tokenjeit a `PLACEHOLDER`-re cseréli. Visszaadja a redaktált szöveget +
+     * a redakciók számát (a per-fájl audit-loghoz). Ha nincs találat → az eredeti szöveg + `count: 0` (no-op).
+     */
+    static redact(text) {
+        let count = 0;
+        let result = text;
+        for (const pattern of FAM_SecretContent_Util.PATTERNS) {
+            result = result.replace(pattern.re, () => {
+                count++;
+                return FAM_SecretContent_Util.PLACEHOLDER;
+            });
+        }
+        return { text: result, count: count };
+    }
+    /** `true`, ha a `text` legalább egy magas-konfidenciájú secret-tokent tartalmaz (a `redact`-re épül, állapotmentes). */
+    static hasSecret(text) {
+        return FAM_SecretContent_Util.redact(text).count > 0;
+    }
+}
+exports.FAM_SecretContent_Util = FAM_SecretContent_Util;

package/build/src/_modules/ingest/_collections/fam-secret-exclude.util.js

@@ -45,6 +45,14 @@ class FAM_SecretExclude_Util {
         /secret/i, // *secret* (csak nem-forrás kiterjesztésen)
         /credential/i, // *credential* (csak nem-forrás kiterjesztésen)
     ];
+    /**
+     * EXPLICIT key-store fájlnevek (user-FR 2026-06-21) — kiterjesztéstől függetlenül kizárnak, mert a fájl MAGA egy
+     * kulcs-tár (élő lelet: egy OpenAI-kulcs `gpt-keys.const.ts`-ben). TIGHT lista (api/gpt/secret/access + `key(s)`)
+     * → alacsony false-positive (egy general `environment.ts`-t NEM zár ki — abban a tartalmi redaktor fogja a kulcsot).
+     */
+    static SECRET_KEYSTORE_NAME_PATTERNS = [
+        /(^|[-_.])(api|gpt|secret|access|private|auth)[-_]?keys?([-_.]|$)/i, // gpt-keys.const.ts, api-keys.ts, apikeys.js
+    ];
     /** Ismert FORRÁS-/DOC-kiterjesztések — ezeken a SOFT névrész-minta NEM zár ki (legit kód/doc). */
     static SOURCE_DOC_EXTENSION = /\.(ts|tsx|mts|cts|js|jsx|mjs|cjs|md|markdown)$/i;
     /** A secret-mappák (az útvonal BÁRMELY szegmense — pl. `secrets/`, `.ssh/`). */
@@ -67,6 +75,10 @@ class FAM_SecretExclude_Util {
         if (FAM_SecretExclude_Util.HARD_SECRET_PATTERNS.some((pattern) => pattern.test(fileName))) {
             return true;
         }
+        // (2b) EXPLICIT key-store fájlnév (api-/gpt-/secret-keys…) — kiterjesztéstől függetlenül (a fájl maga kulcs-tár).
+        if (FAM_SecretExclude_Util.SECRET_KEYSTORE_NAME_PATTERNS.some((pattern) => pattern.test(fileName))) {
+            return true;
+        }
         // (3) SOFT névrész-minta — CSAK ha NEM ismert forrás-/doc-kiterjesztés (a "secret"-nevű .ts legit kód).
         if (FAM_SecretExclude_Util.SOURCE_DOC_EXTENSION.test(fileName)) {
             return false;

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

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

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

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

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

@@ -4,6 +4,7 @@ exports.Api_Controller = void 0;
 const fsm_dynamo_1 = require("@futdevpro/fsm-dynamo");
 const nts_dynamo_1 = 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");
@@ -104,6 +105,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 +141,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 CLI/UI/agent látja a memória-állapotot).
+                    const memory = fam_heap_guard_control_service_1.FAM_HeapGuard_ControlService.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 },
+                    });
                 },
             ],
         });
@@ -406,11 +416,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 = fam_heap_guard_control_service_1.FAM_HeapGuard_ControlService.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)}%, `
+                + `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/app.server.js

@@ -12,7 +12,10 @@ 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");
 /**
  * FDP Agent Memory Server App — Pure Dynamo, **AUTH NÉLKÜL** (ADR-004).
  *
@@ -32,6 +35,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 +44,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).
@@ -115,7 +119,33 @@ 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();
         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) => {

package/package.json

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