@futdevpro/fdp-agent-memory 1.1.12 → 1.1.21

package/build/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@futdevpro/fdp-agent-memory",
-    "version": "1.1.12",
+    "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/_cli/_commands/serve.command.js

@@ -1,7 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FAM_Serve_Util = void 0;
+const tslib_1 = require("tslib");
 const child_process_1 = require("child_process");
+const net = tslib_1.__importStar(require("net"));
 const fs_1 = require("fs");
 const os_1 = require("os");
 const path_1 = require("path");
@@ -147,7 +149,13 @@ class FAM_Serve_Util {
         if (action === 'restart') {
             fam_output_util_1.FAM_Output_Util.logInfo(globals, `FAM szerver RESTART: a(z) ${port} porton futó szerver leállítása…`);
             await FAM_Serve_Util.stopServerOnPort(port);
-            await FAM_Serve_Util.waitForPortDown(client, 8000);
+            // A health-down NEM elég: az új szerver bind-preflight-je a TÉNYLEGESEN SZABAD (bindolható) portot
+            // igényli (a kill utáni process-halál + TIME_WAIT lassú lehet) → a port bindolhatóságát várjuk.
+            const freed = await FAM_Serve_Util.waitForPortFree(port, 12000);
+            if (!freed) {
+                fam_output_util_1.FAM_Output_Util.logInfo(globals, `⚠ a(z) ${port} port 12s alatt nem szabadult fel — az indítás megpróbálom, `
+                    + 'de ha bind-hiba van, futtasd újra a `fam serve --restart`-ot.');
+            }
         }
         return FAM_Serve_Util.spawnServer({ globals: globals, local: local, port: port, healthUrl: healthUrl, client: client });
     }
@@ -265,14 +273,24 @@ class FAM_Serve_Util {
         return false;
     }
     /** A port LE-állásának bevárása (a `--restart` kill után, mielőtt újraindítunk), felső korláttal. */
-    static async waitForPortDown(client, timeoutMs) {
+    static async waitForPortFree(port, timeoutMs) {
         const deadline = Date.now() + timeoutMs;
         while (Date.now() < deadline) {
-            if (!(await client.isReachable(1000))) {
-                return;
+            if (await FAM_Serve_Util.isPortFree(port)) {
+                return true;
             }
             await FAM_Serve_Util.sleep(FAM_Serve_Util.HEALTH_POLL_MS);
         }
+        return false;
+    }
+    /** Bindolható-e (szabad-e) a port? Egy próba-`listen` a loopbackon, azonnali close — `true`, ha köthető. */
+    static isPortFree(port) {
+        return new Promise((resolveCheck) => {
+            const tester = net.createServer();
+            tester.once('error', () => resolveCheck(false));
+            tester.once('listening', () => tester.close(() => resolveCheck(true)));
+            tester.listen(port, '127.0.0.1');
+        });
     }
     /**
      * A megadott porton FIGYELŐ process leállítása (a `--restart` magja). Platform-natív, fail-safe: Windows →
@@ -284,7 +302,12 @@ class FAM_Serve_Util {
         const command = isWin ? (process.env.ComSpec ?? 'powershell.exe') : 'sh';
         const psScript = `$ErrorActionPreference='SilentlyContinue';`
             + `(Get-NetTCPConnection -LocalPort ${port} -State Listen).OwningProcess | Select-Object -Unique | `
-            + `ForEach-Object { Stop-Process -Id $_ -Force }`;
+            + `ForEach-Object { Stop-Process -Id $_ -Force };`
+            // A serve-ablakot (a fam-server-<port>.ps1-t futtató powershell) is leállítjuk → nincs árva,
+            // „[FAM szerver kilépett]" zombi-ablak a restart után (különben halmozódnak).
+            + `Get-CimInstance Win32_Process -Filter "Name='powershell.exe'" | `
+            + `Where-Object { $_.CommandLine -like '*fam-server-${port}*' } | `
+            + `ForEach-Object { Stop-Process -Id $_.ProcessId -Force }`;
         const args = isWin
             ? ['-NoProfile', '-Command', psScript]
             : ['-c', `lsof -ti tcp:${port} | xargs -r kill -9`];

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 {