@futdevpro/fdp-agent-memory 1.1.14 → 1.1.30

package/build/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@futdevpro/fdp-agent-memory",
-    "version": "1.1.14",
+    "version": "1.1.30",
     "description": "Local-first, vector-backed multi-table agent memory exposed as an MCP server (read/write/capabilities). Public, FDP-Templates-free, no auth.",
     "private": false,
     "publishConfig": {
@@ -55,7 +55,7 @@
     "license": "FDP",
     "dependencies": {
         "@futdevpro/fsm-dynamo": "^1.16.7",
-        "@futdevpro/nts-dynamo": "^1.15.72",
+        "@futdevpro/nts-dynamo": "^1.15.74",
         "@modelcontextprotocol/sdk": "^1.12.0",
         "axios": "~1.8.1",
         "better-sqlite3": "^12.4.1",

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");
@@ -21,11 +22,13 @@ class FAM_ScanProjects_Util {
             .description('Több projekt SOROS scan-je (auto-felderítés --root-tal vagy explicit --config-gal; nincs '
             + 'konkurrens thrash). ⚠️ MINDEN projekt-gyökérbe előbb `.fdpfamignore` + `--dry-run` (lásd lent).')
             .option('--root <dir>', 'projekt-gyökerek auto-felderítése e mappa alatt (package.json/.git markerek)')
-            .option('--config <file.json>', 'explicit projekt-lista: [{ path, project, org?, table? }]')
+            .option('--config <file.json>', 'explicit projekt-lista JSON — elemenként `path` + `project` (+ opcionális `org`, `table`)')
             .option('--depth <n>', 'auto-felderítés max mélysége (default 3)', '3')
             .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

@@ -87,7 +87,7 @@ exports.CONFIG_CATALOG = {
     'read.importChunkWeight': {
         type: 'number', default: 0.4, min: 0.0, max: 1.0, levels: ALL_LEVELS,
         description: 'Az import-only chunkok (`chunkType:"imports"`) read-idejű rangsor-szorzója (FAM-REV-060). '
-            + 'A szimbólum-név query-knél az import-sorok (`import { X } from "./y"`) magas cosine-t kapnak, de '
+            + 'A szimbólum-név query-knél az import-sorok (`import { X: X } from "./y"`) magas cosine-t kapnak, de '
             + 'alacsony az ÉRTÉKük (csak import, nem definíció) → e szorzóval a `finalScore = score × weight × '
             + 'importChunkWeight` a definíció-chunkok ALÁ rangsorolja őket. READ-time (nincs re-embed); a nyers '
             + 'cosine score (relevancia-jelzések) NEM változik, csak a ranking. 1 = nincs csökkentés.',
@@ -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,9 @@ 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).',
     },
+    // (Az OOM-hibakezelés/heap-guard configja a BEDROCK `DyNTS_global_settings.memoryGuard`-ban van — NEM FAM-config:
+    // a bedrock `DyNTS_MemoryGuard`-ot a base App auto-installálja, a FAM a thresholdokat az `overrideDynamoNTSGlobalSettings`-ben
+    // állítja. Ezért nincs FAM `memory.*` config-kulcs.)
     '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/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/capture/_services/fam-auto-capture.control-service.js

@@ -48,7 +48,7 @@ class FAM_AutoCapture_ControlService {
         const contentHash = ingest_1.FAM_ContentHash_Util.hash(content);
         // Dedup: van-e MÁR aktív memory-bejegyzés azonos content-hash-sel? → idempotens skip (nincs duplikátum).
         const existing = await this.findByHash(contentHash);
-        if (existing && existing._id) {
+        if (existing?._id) {
             return { captured: false, skipped: 'duplicate', id: existing._id, contentHash: contentHash };
         }
         // Új capture → a `write` create-úton (agent-provenance, auto-embed). A `source.path` a sessionId

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

@@ -215,7 +215,7 @@ class FAM_EmbeddingPipeline_ControlService {
     }
     /** A scope-szűkítő filter (a `scopePath` LEVÉL scopeId-jára). Üres scope → teljes tár (`!_deleted`). */
     buildScopeFilter(scopePath) {
-        if (scopePath && scopePath.length) {
+        if (scopePath?.length) {
             const leaf = scopePath[scopePath.length - 1];
             const filter = { 'scopePath.scopeId': leaf.scopeId };
             return filter;

package/build/src/_modules/embedding/_services/fam-entry.data-service.js

@@ -2,8 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FAM_Entry_DataService = void 0;
 const tslib_1 = require("tslib");
-const nts_dynamo_1 = require("@futdevpro/nts-dynamo");
 const mongoose_1 = tslib_1.__importDefault(require("mongoose"));
+const nts_dynamo_1 = require("@futdevpro/nts-dynamo");
 const fam_entry_data_model_1 = require("../../../_models/data-models/fam-entry.data-model");
 /**
  * `FAM_Entry_DataService` (SP-2.2) — egy GENERIKUS, tár-paraméteres entry-CRUD a vektor-rétegnek.
@@ -195,5 +195,27 @@ class FAM_Entry_DataService extends nts_dynamo_1.DyNTS_DataService {
         filterBy['position.charStart'] = { $ne: position.charStart };
         await this.updateData({ filterBy: filterBy, update: update });
     }
+    /**
+     * A **git-repo provenance** (`source.repoUrl` / `repoName` / `repoRelativePath` / `repoBranch`) FELTÉTELES
+     * backfill-je (user-FR 2026-06-22) — a re-scan `equal` (változatlan-content) ágán hívva, hogy a CSAK-metaadat
+     * frissítés (a git-provenance feature ELŐTT ingestelt korpuszra) RE-EMBED NÉLKÜL megtörténjen. A hívó (ingest)
+     * adja a kiszámolt `git`-mezőket (a `FAM_GitRepo_Util`-t a control-service importálja — nincs modul-ciklus). Nem
+     * git-repo (nincs `repoUrl`) → no-op. Feltétel: a per-fájl `repoRelativePath` `$ne` (a Mongo no-op, ha már stimmel).
+     */
+    async backfillGitProvenance(id, git) {
+        if (!git.repoUrl) {
+            return;
+        }
+        const setBlock = {
+            ['source.repoUrl']: git.repoUrl,
+            ['source.repoName']: git.repoName,
+            ['source.repoRelativePath']: git.repoRelativePath,
+            ['source.repoBranch']: git.repoBranch,
+        };
+        const update = { $set: setBlock };
+        const filterBy = { _id: id };
+        filterBy['source.repoRelativePath'] = { $ne: git.repoRelativePath };
+        await this.updateData({ filterBy: filterBy, update: update });
+    }
 }
 exports.FAM_Entry_DataService = FAM_Entry_DataService;

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;