@futdevpro/fdp-agent-memory 1.1.12 → 1.1.21

package/build/src/_modules/ingest/_collections/fam-git-repo.util.js

@@ -0,0 +1,193 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FAM_GitRepo_Util = void 0;
+const tslib_1 = require("tslib");
+const fs = tslib_1.__importStar(require("fs"));
+const path = tslib_1.__importStar(require("path"));
+/**
+ * `FAM_GitRepo_Util` (user-FR 2026-06-21) — egy scannelt fájlhoz felderíti a **git-repo provenance-t**:
+ * a repo-gyökeret (`.git` felfelé keresve), a **GitHub/remote URL-t** (`.git/config` `remote.origin.url`,
+ * normalizálva), a **branch-et** (`.git/HEAD`) és a **repo-gyökérhez relatív utat**. **Függőség-mentes**
+ * (NEM `git`-parancs — közvetlenül a `.git/` fájlokból olvas; gyors + offline). A scan **repoRoot-onként cache-eli**
+ * (egy mappa-scan ~1 repo → egyszer olvas), így a per-fájl költség elhanyagolható.
+ *
+ * Miért így (a user „relative path + GitHub repo" döntése): a repo-URL + a **REPO-relatív** út KANONIKUS,
+ * gép-független, kattintható citáció (`<repoUrl>/blob/<branch>/<repoRelativePath>`) — szemben a gép-specifikus
+ * abszolút úttal vagy a törékeny „projektnévből kiszámolt" relatív úttal.
+ */
+class FAM_GitRepo_Util {
+    /** Meddig megyünk felfelé `.git`-et keresve (biztonsági korlát a végtelen ciklus ellen). */
+    static MAX_WALK_UP = 40;
+    /** Belső repoRoot→info cache (a scan-során a `.git` nem változik; egy repo → egyszer olvas). */
+    static _cache = new Map();
+    /**
+     * Egy scannelt fájl **scan-source git-mezői** (a `FAM_Source`-ba spread-elve): `repoUrl` / `repoName` /
+     * `repoRelativePath` (a repo-gyökérhez) / `repoBranch`. Cache-elt (belső statikus Map) + fail-safe (üres
+     * objektum, ha a fájl NINCS git-repóban / hiba) — a scan SOHA nem bukik el a git-felderítésen.
+     */
+    static sourceFieldsFor(absFilePath) {
+        try {
+            const info = FAM_GitRepo_Util.resolve(absFilePath, FAM_GitRepo_Util._cache);
+            if (!info) {
+                return {};
+            }
+            return {
+                repoUrl: info.repoUrl,
+                repoName: info.repoName,
+                repoRelativePath: FAM_GitRepo_Util.relativePath(absFilePath, info.repoRoot),
+                repoBranch: info.repoBranch,
+            };
+        }
+        catch {
+            return {};
+        }
+    }
+    /**
+     * A teljes repo-info felderítése egy fájl abszolút útjából, **cache-elve a repoRoot-on** (a hívó adja a
+     * Map-et; egy scan végig egyet használ). `null`, ha a fájl NINCS git-repóban. A relatív utat a hívó a
+     * `relativePath`-szal számolja (a repoRoot ismeretében).
+     */
+    static resolve(absFilePath, cache) {
+        const repoRoot = FAM_GitRepo_Util.findRepoRoot(absFilePath);
+        if (!repoRoot) {
+            return null;
+        }
+        const cached = cache.get(repoRoot);
+        if (cached !== undefined) {
+            return cached;
+        }
+        const remote = FAM_GitRepo_Util.readRemoteUrl(repoRoot);
+        const info = {
+            repoRoot: repoRoot,
+            repoUrl: remote?.url,
+            repoName: remote?.name,
+            repoBranch: FAM_GitRepo_Util.readBranch(repoRoot),
+        };
+        cache.set(repoRoot, info);
+        return info;
+    }
+    /** A repo-gyökér keresése felfelé (`.git` mappa VAGY fájl — a submodule `.git` fájl). `null`, ha nincs. */
+    static findRepoRoot(absStartPath) {
+        let dir = absStartPath;
+        try {
+            // Ha a start egy fájl, a könyvtárából indulunk; ha mappa, magából.
+            if (fs.existsSync(absStartPath) && fs.statSync(absStartPath).isFile()) {
+                dir = path.dirname(absStartPath);
+            }
+        }
+        catch {
+            dir = path.dirname(absStartPath);
+        }
+        for (let i = 0; i < FAM_GitRepo_Util.MAX_WALK_UP; i++) {
+            if (fs.existsSync(path.join(dir, '.git'))) {
+                return dir;
+            }
+            const parent = path.dirname(dir);
+            if (parent === dir) {
+                return null; // elértük a filesystem-gyökeret
+            }
+            dir = parent;
+        }
+        return null;
+    }
+    /**
+     * A `remote.origin.url` kiolvasása a `.git/config`-ból + normalizálva (`https://github.com/owner/repo`).
+     * `undefined`, ha nincs origin / nem olvasható. (A submodule `.git` FÁJL `gitdir:`-re mutat — ezt is követjük.)
+     */
+    static readRemoteUrl(repoRoot) {
+        try {
+            const gitPath = path.join(repoRoot, '.git');
+            const configPath = fs.statSync(gitPath).isDirectory()
+                ? path.join(gitPath, 'config')
+                : path.join(FAM_GitRepo_Util.resolveGitdir(repoRoot, gitPath), 'config');
+            if (!fs.existsSync(configPath)) {
+                return undefined;
+            }
+            const raw = fs.readFileSync(configPath, 'utf-8');
+            const rawUrl = FAM_GitRepo_Util.extractOriginUrl(raw);
+            return rawUrl ? FAM_GitRepo_Util.normalizeRepoUrl(rawUrl) : undefined;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    /** A `.git/HEAD`-ből az aktuális branch (`ref: refs/heads/<branch>`); detached SHA / hiba → `undefined`. */
+    static readBranch(repoRoot) {
+        try {
+            const gitPath = path.join(repoRoot, '.git');
+            const headPath = fs.statSync(gitPath).isDirectory()
+                ? path.join(gitPath, 'HEAD')
+                : path.join(FAM_GitRepo_Util.resolveGitdir(repoRoot, gitPath), 'HEAD');
+            const head = fs.readFileSync(headPath, 'utf-8').trim();
+            const match = head.match(/^ref:\s*refs\/heads\/(.+)$/);
+            return match ? match[1].trim() : undefined;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    /** A fájl REPO-gyökérhez relatív útja (POSIX-szeparátorral, a kattintható citációhoz). */
+    static relativePath(absFilePath, repoRoot) {
+        return path.relative(repoRoot, absFilePath).replace(/\\/g, '/');
+    }
+    /**
+     * A nyers remote-URL normalizálása kattintható HTTPS-formára + `owner/repo` névre. Lefedi:
+     * `git@host:owner/repo.git`, `https://host/owner/repo.git`, `ssh://git@host/owner/repo.git`. A `.git`-suffix
+     * + a beágyazott credential levágva. Nem-github host esetén a host marad (gitlab/bitbucket is kattintható).
+     */
+    static normalizeRepoUrl(rawUrl) {
+        let url = rawUrl.trim();
+        // scp-szerű: git@host:owner/repo(.git) → https://host/owner/repo
+        const scp = url.match(/^[\w.-]+@([\w.-]+):(.+)$/);
+        if (scp) {
+            url = `https://${scp[1]}/${scp[2]}`;
+        }
+        url = url
+            .replace(/^ssh:\/\/(?:[\w.-]+@)?/, 'https://')
+            .replace(/^git:\/\//, 'https://')
+            .replace(/^https?:\/\/[^@/]+@/, 'https://') // beágyazott credential levágása
+            .replace(/\.git$/, '')
+            .replace(/\/+$/, '');
+        const nameMatch = url.match(/^https?:\/\/[\w.-]+\/(.+?\/[^/]+)$/);
+        return { url: url, name: nameMatch ? nameMatch[1] : undefined };
+    }
+    /** A `[remote "origin"]` szekció `url = …` sora a `.git/config`-ból (defenzív, szekció-tudatos). */
+    static extractOriginUrl(configText) {
+        let inOrigin = false;
+        for (const rawLine of configText.split(/\r?\n/)) {
+            const line = rawLine.trim();
+            const section = line.match(/^\[remote\s+"([^"]+)"\]$/);
+            if (section) {
+                inOrigin = section[1] === 'origin';
+                continue;
+            }
+            if (line.startsWith('[')) {
+                inOrigin = false;
+                continue;
+            }
+            if (inOrigin) {
+                const url = line.match(/^url\s*=\s*(.+)$/);
+                if (url) {
+                    return url[1].trim();
+                }
+            }
+        }
+        return undefined;
+    }
+    /** A submodule `.git` FÁJL (`gitdir: <relpath>`) feloldása a tényleges git-könyvtárra. */
+    static resolveGitdir(repoRoot, gitFilePath) {
+        try {
+            const content = fs.readFileSync(gitFilePath, 'utf-8').trim();
+            const match = content.match(/^gitdir:\s*(.+)$/);
+            if (match) {
+                const target = match[1].trim();
+                return path.isAbsolute(target) ? target : path.resolve(repoRoot, target);
+            }
+        }
+        catch {
+            /* fall through */
+        }
+        return gitFilePath;
+    }
+}
+exports.FAM_GitRepo_Util = FAM_GitRepo_Util;

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,7 +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");
@@ -185,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);
@@ -211,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
@@ -271,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)) {
@@ -408,6 +431,8 @@ class FAM_Ingest_ControlService {
             headingPath: set.chunk.headingPath,
             source: {
                 type: 'scan', path: set.file.relativePath, root: set.root, absolutePath: set.file.absolutePath,
+                // Git-repo provenance (user-FR): repoUrl + repoRelativePath + repoBranch → kattintható citáció.
+                ...fam_git_repo_util_1.FAM_GitRepo_Util.sourceFieldsFor(set.file.absolutePath),
             },
             addedBy: 'scan',
             ingestRunId: set.runId,
@@ -591,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) {
@@ -648,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);