@futdevpro/fdp-agent-memory 1.1.163 → 1.1.177

package/build/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@futdevpro/fdp-agent-memory",
-    "version": "1.1.163",
+    "version": "1.1.177",
     "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": {
@@ -19,7 +19,13 @@
         "build",
         "client-dist",
         "README.md",
-        "LICENSE"
+        "LICENSE",
+        "!build/**/*.spec.js",
+        "!build/**/*.spec.js.map",
+        "!build/**/*.spec.d.ts",
+        "!build/**/_benchmarks/**",
+        "!build/**/_integration-tests/**",
+        "!build/**/_spec-support/**"
     ],
     "engines": {
         "node": ">=20"

package/build/src/_cli/_commands/prune-duplicates.command.js

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FAM_PruneDuplicates_Util = void 0;
+const commander_1 = require("commander");
+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");
+/**
+ * `fam prune-duplicates [--table t] [--apply]` — BÁJTAZONOS ismétlés-nyesés.
+ *
+ * Az azonos `(absolutePath, chunkIndex, chunkTotal, contentHash)` négyesű példányok között NINCS
+ * információ-különbség: a legfrissebbet megtartjuk, a többit soft-delete-eljük, és a csoport
+ * `recallCount` / `lastRecalledAt` MAXIMUMÁT átvisszük a megtartottra (a felidézés-történet nem veszhet el).
+ *
+ * **Alapértelmezés a DRY-RUN** — a törléshez explicit `--apply` kell. A `find-duplicates`-szel NEM
+ * keverendő: az SZEMANTIKAI hasonlóságot keres (koszinusz-cluster) és szándékosan sosem töröl.
+ *
+ * `superseded` bejegyzést tartalmazó csoporthoz SOHA nem nyúl (az a `memory` tár szándékos, leváltott
+ * generációja) — a kihagyás számláltan látszik a riportban.
+ *
+ * ⏱️ **FUTÁSIDŐ (mérve 2026-09-01, 555k aktív chunk):** a TELJES korpusz **~123 s**, egyetlen tár (`rules`)
+ * **~1,4 s**. Ez egy hosszan futó, szinkron aggregáció — automatizált hívónál (CI, HTTP-kliens) vagy emeld
+ * a timeoutot, vagy `--table`-lel bontsd táranként. A `--max-groups` a MUNKÁT nem, csak a feldolgozott
+ * csoportok számát korlátozza (az aggregáció akkor is végigmegy).
+ */
+class FAM_PruneDuplicates_Util {
+    /** A `prune-duplicates` parancs-deszkriptor. */
+    static command() {
+        const command = new commander_1.Command('prune-duplicates');
+        command
+            .description('Bájtazonos ismétlés-nyesés (a legfrissebb marad; DRY-RUN az alapértelmezés)')
+            .option('--table <table>', 'csak ez a tár (default: MINDEN tár)')
+            .option('--apply', 'a nyesés TÉNYLEGES végrehajtása (enélkül csak mér, nem ír)')
+            .option('--max-groups <n>', 'csoport-plafon egy futásra (default 50000; a capped jelzi, ha több)')
+            .action(async () => {
+            fam_output_util_1.FAM_Output_Util.exit(await FAM_PruneDuplicates_Util.run(command));
+        });
+        return command;
+    }
+    /** A `prune-duplicates` futtatása a REST `POST /api/duplicates/prune`-on. */
+    static async run(command) {
+        const globals = command.optsWithGlobals();
+        const local = command.opts();
+        const client = new fam_client_service_1.FAM_CliClient_Service(globals.serverUrl);
+        const maxGroups = local.maxGroups !== undefined ? Number(local.maxGroups) : undefined;
+        const result = await client.post('/api/duplicates/prune', {
+            table: local.table,
+            // A `--apply` HIÁNYA a biztonságos irány: dryRun marad. Elgépelt kapcsoló sosem töröl.
+            dryRun: local.apply !== true,
+            maxGroups: Number.isFinite(maxGroups) ? maxGroups : undefined,
+        });
+        if (!result.ok) {
+            return fam_output_util_1.FAM_Output_Util.failure({
+                options: globals,
+                command: 'prune-duplicates',
+                error: result.error ?? { errorCode: 'FAM-CLI-PRUNE-001', message: 'Ismeretlen nyesési hiba.' },
+                exitCode: result.unreachable ? fam_cli_const_1.FAM_CliExitCode.serverUnreachable : fam_cli_const_1.FAM_CliExitCode.operationError,
+            });
+        }
+        return fam_output_util_1.FAM_Output_Util.success({
+            options: globals,
+            command: 'prune-duplicates',
+            data: result.data,
+            humanFormatter: (data) => FAM_PruneDuplicates_Util.format(data),
+        });
+    }
+    /** Ember-olvasható összegzés: per-tár sorok + összesítés + a dry-run explicit jelzése. */
+    static format(report) {
+        const lines = [];
+        lines.push(report.dryRun
+            ? 'Bájtazonos ismétlés-nyesés — DRY-RUN (semmi nem változott; a végrehajtáshoz: --apply):'
+            : 'Bájtazonos ismétlés-nyesés — VÉGREHAJTVA:');
+        for (const row of report.tables) {
+            if (!row.groups) {
+                continue;
+            }
+            lines.push(`  ${row.table.padEnd(18)} ${String(row.groups).padStart(6)} csoport`
+                + ` → ${String(row.prunedChunks).padStart(6)} chunk`
+                + `${row.recallCarried ? `, ${row.recallCarried} felidézés-történet átvive` : ''}`
+                + `${row.skippedSuperseded ? `, ${row.skippedSuperseded} superseded KIHAGYVA` : ''}`
+                + `${row.capped ? '  ⚠ CAPPED (emeld a --max-groups-ot, vagy futtasd újra)' : ''}`);
+        }
+        if (!report.totalGroups) {
+            lines.push('  ✓ nincs bájtazonos ismétlés.');
+            return lines.join('\n');
+        }
+        lines.push(`  ÖSSZESEN: ${report.totalGroups} csoport, ${report.totalPrunedChunks} felesleges chunk`
+            + `, ${report.totalRecallCarried} felidézés-történet átvive`
+            + `, ${report.totalSkippedSuperseded} superseded csoport érintetlen.`);
+        return lines.join('\n');
+    }
+}
+exports.FAM_PruneDuplicates_Util = FAM_PruneDuplicates_Util;

package/build/src/_cli/register-commands.js

@@ -8,6 +8,7 @@ const scan_projects_command_1 = require("./_commands/scan-projects.command");
 const config_command_1 = require("./_commands/config.command");
 const stats_command_1 = require("./_commands/stats.command");
 const find_duplicates_command_1 = require("./_commands/find-duplicates.command");
+const prune_duplicates_command_1 = require("./_commands/prune-duplicates.command");
 const errors_command_1 = require("./_commands/errors.command");
 const init_command_1 = require("./_commands/init.command");
 const doctor_command_1 = require("./_commands/doctor.command");
@@ -56,6 +57,7 @@ function registerFAMCommands(program, version) {
         remote_command_1.FAM_Remote_Util.command(),
         stats_command_1.FAM_Stats_Util.command(),
         find_duplicates_command_1.FAM_FindDuplicates_Util.command(),
+        prune_duplicates_command_1.FAM_PruneDuplicates_Util.command(),
         errors_command_1.FAM_Errors_Util.command(),
         // 7 delegáló alias (README copy-paste-elhetőség, nincs külön logika; dsgn-010 §10).
         doctor_command_1.FAM_Doctor_Util.aliasCommand('validate-env', ['env']),

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

@@ -37,6 +37,18 @@ exports.SCAN_IGNORE_PATTERNS_DEFAULT = [
     // Generált report-ok / logok / teszt-artefaktumok (FAM-REV-057) — minifikált HTML / nagy JSON-log → embed-hang
     // (pl. dynamo-ngx: 515KB playwright-report HTML, 320KB .dynamo/logs status.json, 173KB logs/cicd-report.json).
     '**/playwright-report/**', '**/test-results/**', '**/.dynamo/**', '**/logs/**', '**/*.log', '**/*-report.json',
+    // GENERÁLT audit-/report-/evidence-artefaktumok (2026-08-22, a játék-projektek beemelésekor mérve). A fenti
+    // `*-report.json` TÚL SZŰK volt: a VERZIÓZOTT nevek (`asset-qa-report-v14.json`, `cat-animation-audit-v12.json`)
+    // átcsúsztak rajta. Mérve a teljes codebase táron: `evidence.json` 1082 chunk / 1,17M char (detektor-kimenet),
+    // `*-report*` 788, `*-audit*` 589, `asset|atlas-manifest` 257 (pixel-koordináták, occupancy-arányok),
+    // `dom-snapshot` 192, `*-capture` 153.
+    '**/*-report*.json', '**/*-audit*.json', '**/evidence.json', '**/dom-snapshot*.json', '**/*-capture.json',
+    '**/asset-manifest*.json', '**/atlas-manifest*.json',
+    // ⚠️ SZÁNDÉKOSAN NEM `**/reports/**` és NEM `**/manifest.json`:
+    //  - a `reports/` mappa-minta **4053 markdown DOKSI-chunkot** zárt volna ki (`__documentations/reports/…`),
+    //    ezért csak az e2e generált riport-mappája megy ki;
+    //  - a sima `manifest.json` a Unity `Packages/manifest.json` = a FÜGGŐSÉG-LISTA, ami valódi érték.
+    '**/e2e/reports/**',
     '**/*.min.js', '**/*.min.css', '**/*.map', '**/.env', '**/.env.*', '**/*.pem', '**/*.key',
     '**/*.secret', '**/secrets/**', '**/*.lock', '**/package-lock.json', '**/pnpm-lock.yaml',
     // Python (L4) — bytecode/venv/teszt-/lint-cache + telepített csomagok (SOHA nem forrás; a `*.pyc`/`*.pyo`
@@ -50,6 +62,19 @@ exports.SCAN_IGNORE_PATTERNS_DEFAULT = [
     // lowercase NEM matchelné a Unity `Logs/`-át).
     '**/Library/**', '**/Temp/**', '**/Obj/**', '**/obj/**', '**/bin/**', '**/Logs/**', '**/Build/**', '**/Builds/**',
     '**/.vs/**', '**/*.csproj', '**/*.sln', '**/*.meta', '**/*.unity', '**/*.prefab', '**/*.asset',
+    // Unity GÉPI SZERIALIZÁCIÓ — szöveges fájlok, ezért a bináris-routing ÁTENGEDTE őket, de a tartalmuk
+    // GUID-leves / YAML objektum-gráf / animációs görbe / mesh-vertex: NULLA emberi tudás. Mérve (2026-08-22, a
+    // játék-projektek beemelése után): **9 017 chunk / 9,5M karakter** csak ezekből — `.shadergraph` 4344,
+    // `.dwlt` 1105, `.anim` 1086, `.shadersubgraph` 1075, `.mat` 685, `.vfx` 281, `.controller` 178. És nem is
+    // csak holt teher: egy „shader for the water surface" query top-5-jéből **4 slot** ilyen szemét volt, a
+    // „UI button click handler"-ből 2 — a grafikai/UI kérdéseket gyakorlatilag használhatatlanná tette.
+    // A `.shader`/`.hlsl`/`.compute` SZÁNDÉKOSAN MARAD: azok kézzel írt forrás.
+    '**/*.shadergraph', '**/*.shadersubgraph', '**/*.vfx', '**/*.mat', '**/*.physicMaterial', '**/*.physicsMaterial2D',
+    '**/*.controller', '**/*.overrideController', '**/*.anim', '**/*.playable', '**/*.signal', '**/*.mask',
+    '**/*.terrainlayer', '**/*.brush', '**/*.inputactions', '**/*.lighting', '**/*.giparams', '**/*.cubemap',
+    '**/*.flare', '**/*.fontsettings', '**/*.guiskin', '**/*.spriteatlas', '**/*.spriteatlasv2', '**/*.mixer',
+    // Unity editor-layout + 3D-mesh + szerkesztői mentés (a `.obj` ProBuilder-generált geometria, nem forrás).
+    '**/*.dwlt', '**/*.obj', '**/*.fbx', '**/*.blend', '**/*.bak',
     // Agent-/böngésző-state (lokális futás-melléktermék, SOHA nem korpusz-anyag): `.local-state` (pl. agent
     // browser-automation profil) + Chromium-profil/cache — lockolt SQLite + bináris blobok (Login Data /
     // Cookies / Web Data = SZEMÉLYES adat), olvashatatlanok + junk. (Lelet 2026-06-22: fdp-assistant/__agent/
@@ -162,6 +187,37 @@ exports.CONFIG_CATALOG = {
             + 'Mert indok (2026-08-22): kontrollalt teszten a rules tar 0/3 aranyban tunt el a documents mogott, '
             + 'holott a csak-rules query azonnal hozta a kanonikus szabalyt.',
     },
+    // KERESZT-TAR "mellesleg"-javaslat (2026-09-01). A `memory`/`knowledge` a HIBAKERESES-jellegu kerdeseken
+    // eros ("miert tort el", "lattuk mar ezt"), de az agent jellemzoen `codebase`/`documents`-ben keres, mert
+    // nem tudja, hogy ott van. Merve 15 realisztikus kerdesen: 13-nal az ELSODLEGES tar volt jobb -> a talalat
+    // NEM kerulhet a listaba (13 esetben rontanank, hogy 2-ben javitsunk), csak kulon, egyetlen mellek-mezobe.
+    'read.crossTableNoteEnabled': {
+        type: 'boolean', default: true, levels: ALL_LEVELS,
+        description: 'Kereszt-tar "mellesleg"-javaslat: ha a memory/knowledge taron ERDEMBEN erosebb talalat van, '
+            + 'a valasz kap egy kulon `crossTableNote` mezot. A `hits` VALTOZATLAN marad (sem sorrend, sem tagsag). '
+            + 'Nem fut, ha a hivo eleve kerte ezeket a tarakat. Merve: +376 ms (+14%) a szonda koltsege.',
+    },
+    'read.crossTableNoteMinDelta': {
+        type: 'number', default: 0.025, min: 0, max: 1, levels: ALL_LEVELS,
+        description: 'A megszolalashoz szukseges NYERS score-elony. 0 = kikapcsolva. Kalibralva 44 eseten, '
+            + 'KONTROLLCSOPORTTAL (24 strukturalis kerdes + 20 diagnosztikai). FONTOS: az elso kalibracio '
+            + '0,12-t adott, de kiderult, hogy a magas deltakat szinte kizarolag beszelgetes-tormelek '
+            + '(user_prompt / temporary_context, a memory tar 20,2%-a) termelte. A tormelek kizarasa utan '
+            + '0,12-nel a jegyzet SOHA nem szolalt volna meg. A valos jel a 0,025-0,06 savban van, es ott '
+            + 'pontos: 3/44 megszolalas (6,8%), koztuk a docker-cache-token es a lokal-vs-CI tanulsag. '
+            + 'KORLAT: ket kulonbozo tartalomtipus nyers koszinuszat hasonlitja -> korpusz-valtaskor UJRA KELL MERNI '
+            + '(`node build/src/_benchmarks/fam-crosstable-bench.js`).',
+    },
+    'read.crossTableNoteMinScore': {
+        type: 'number', default: 0.45, min: 0, max: 1, levels: ALL_LEVELS,
+        description: 'Abszolut also korlat a jelolt sajat score-jara: gyenge talalatot akkor sem ajanlunk, '
+            + 'ha az elsodleges tar meg gyengebb (kulonben a "nincs talalat" eset minden alkalommal zajt szulne).',
+    },
+    'read.crossTableNoteTopK': {
+        type: 'number', default: 3, min: 1, max: 10, integer: true, levels: ALL_LEVELS,
+        description: 'A szonda topK-ja taranként. Kicsi: a szonda csak azt donti el, VAN-E erdemben erosebb — '
+            + 'nem masodik talalati listat epit.',
+    },
     'read.relevanceFloor': {
         type: 'number', default: 0.60, min: 0.0, max: 1.0, levels: ALL_LEVELS,
         // PER-TÁR kalibráció (2026-08-14 MÉRÉS): a tárak score-tartománya ELTÉR — a `codebase`/`documents` szimbólum-

package/build/src/_models/data-models/fam-entry-base-properties.const.js

@@ -29,6 +29,7 @@ exports.famEntryBaseProperties = {
     referenceLinks: { type: 'string[]', default: [] },
     referenceCodes: { type: 'string[]', index: true, default: [] },
     weight: { type: 'number', default: 1 },
+    projectWeight: { type: 'number' },
     importance: { type: 'number', index: true },
     source: { type: 'object' },
     sourceFilePath: { type: 'string', index: true },

package/build/src/_models/data-models/fam-entry.data-model.js

@@ -55,6 +55,14 @@ class FAM_Entry extends fsm_dynamo_1.DyFM_Metadata {
     // --- pontozás ---
     /** Retrieval-score multiplikátor (`> 0`); `0` → kizárt. Default `1.0` (per-tár override). */
     weight = 1;
+    /**
+     * A PROJEKT-szintu retrieval-szorzo a `.famconfig.json`-bol (`FAM_ProjectConfig_Util`). Kulon mezo a
+     * `weight`-tol, mert a `weight` a temperalason (`effectiveWeight`) megy at — az `read.weightInfluence: 0.06`
+     * mellett onnan MAXIMUM 6% lehuzas johet, barmilyen alacsony erteket adunk (merve 2026-08-22: `weight: 0.6`
+     * -> 2,4% csokkenes). Ez a mezo TEMPERALATLANUL szorozza a `finalScore`-t, igy a projekt-szintu policy
+     * valodi hatassal bir. Hianyzik/undefined -> 1 (nincs hatas).
+     */
+    projectWeight;
     /** Opcionális kvalitatív hangsúly (0..1). */
     importance;
     // --- Memory Activation Model (dsgn-013, CSAK a `memory` táron értelmezett) ---

package/build/src/_modules/embedding/_collections/fam-exact-duplicate-prune.util.js

@@ -0,0 +1,85 @@
+"use strict";
+/**
+ * PONTOS (bájtazonos) ismétlés-nyesés — a döntési logika, tisztán és tesztelhetően.
+ *
+ * **Miben más ez, mint a `FAM_DuplicateScan_ControlService`?** Az a SZEMANTIKAI hasonlóságot keresi
+ * (koszinusz-cluster) és szándékosan sosem töröl — ott emberi ítélet kell. EZ viszont a BIZONYÍTOTTAN
+ * AZONOS újra-beolvasást nyesi: azonos `(source.absolutePath, chunkIndex, chunkTotal, contentHash)` →
+ * a példányok között NINCS információ-különbség, így az elhagyásuk nem veszteség.
+ *
+ * **Mért indok (2026-09-01):** egy projekt-átnevezés után a heti re-scan cél-uniója MINDKÉT nevet
+ * megtartotta ugyanarra a mappára, a delta-összevetés pedig a levél-scopeId-re szűrt — így a második
+ * menet üres `existing`-et kapott, és mindent `new`-ként vitt be. Az aktív korpuszban ez **13 201**
+ * felesleges chunk (a 555 102 aktívból 2,38%). A gyökér-okot a scope-vak fallback + az útvonal-dedup
+ * javítja; EZ a maradék takarítása.
+ *
+ * **Amihez SOHA nem nyúl:**
+ *  - `superseded` bejegyzés — az a `memory` tár szándékos, leváltott generációja (dsgn-013 MAM F4),
+ *    az owner explicit kérése szerint MEGMARAD („nem baj ha fennmarad olyan memória amit a Claude már
+ *    elfelejtett… sőt!"). Mérve: a `memory` táron 0 bájtazonos csoport van, mind a 287 eltérő tartalmú.
+ *  - ELTÉRŐ `contentHash`-ű példányok — azok valódi tartalom-történet, nem ismétlés (mérve 3 046 csoport).
+ *
+ * **Megőrzött felidézés-történet:** a csoport `recallCount` / `lastRecalledAt` MAXIMUMA a megtartott
+ * példányra vándorol — az owner „amit többet használtunk, az tovább él" elve nem sérülhet a nyesésben.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FAM_ExactDuplicatePrune_Util = void 0;
+class FAM_ExactDuplicatePrune_Util {
+    /**
+     * A megtartandó példány: a LEGFRISSEBB `lastModified`. Döntetlennél a lexikálisan legnagyobb `id`
+     * nyer — nem esztétika, hanem DETERMINIZMUS: a nyesés kétszer futtatva ugyanazt kell adja, különben
+     * a második futás megint mozgatna, és a művelet nem lenne idempotens.
+     */
+    static chooseKeeper(members) {
+        if (!members.length) {
+            return undefined;
+        }
+        return [...members].sort((a, b) => {
+            const at = typeof a.lastModified === 'number' ? a.lastModified : 0;
+            const bt = typeof b.lastModified === 'number' ? b.lastModified : 0;
+            return bt !== at ? bt - at : (a.id < b.id ? 1 : -1);
+        })[0];
+    }
+    /** A csoport felidézés-történetének maximuma (a megtartottra vitt érték bemenete). */
+    static maxRecall(members) {
+        let count = 0;
+        let at = 0;
+        for (const member of members) {
+            if (typeof member.recallCount === 'number' && member.recallCount > count) {
+                count = member.recallCount;
+            }
+            if (typeof member.lastRecalledAt === 'number' && member.lastRecalledAt > at) {
+                at = member.lastRecalledAt;
+            }
+        }
+        return { recallCount: count, lastRecalledAt: at };
+    }
+    /**
+     * Egy csoport nyesési terve — vagy a kihagyás INDOKA. A `carry` csak azt a mezőt tartalmazza, ami a
+     * megtartotton ténylegesen NŐNE: fölösleges írást nem kérünk, és a keeper saját értékét sem rontjuk le.
+     */
+    static planGroup(members) {
+        if (members.length < 2) {
+            return 'single-member';
+        }
+        if (members.some((member) => member.superseded === true)) {
+            return 'superseded-present';
+        }
+        const keeper = FAM_ExactDuplicatePrune_Util.chooseKeeper(members);
+        const max = FAM_ExactDuplicatePrune_Util.maxRecall(members);
+        const carry = {};
+        if (max.recallCount > (keeper.recallCount ?? 0)) {
+            carry.recallCount = max.recallCount;
+        }
+        if (max.lastRecalledAt > (keeper.lastRecalledAt ?? 0)) {
+            carry.lastRecalledAt = max.lastRecalledAt;
+        }
+        return {
+            keepId: keeper.id,
+            dropIds: members.filter((member) => member.id !== keeper.id)
+                .map((member) => member.id),
+            carry: carry,
+        };
+    }
+}
+exports.FAM_ExactDuplicatePrune_Util = FAM_ExactDuplicatePrune_Util;

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

@@ -156,6 +156,27 @@ class FAM_Entry_DataService extends nts_dynamo_1.DyNTS_DataService {
         filterBy['source.root'] = { $ne: root };
         await this.updateData({ filterBy: filterBy, update: update });
     }
+    /**
+     * A `scopePath` FELTÉTELES backfill-je (2026-09-01) — a re-scan `equal` ágán hívva.
+     *
+     * **Miért kell.** A fájl IDENTITÁSA az abszolút útvonal, a scope csak besorolás — ezért az `equal`
+     * összevetés (a scope-vak fallback óta) MÁS scope alatt álló chunkot is adoptál. Enélkül a backfill
+     * nélkül az adoptált chunk ÖRÖKRE a RÉGI projekt-név alatt maradna: a duplikáció megszűnne, de a
+     * scope-szűrt keresés az ÚJ néven nem találná meg. A régi viselkedés (teljes duplikálás) legalább
+     * hagyott egy példányt az új scope alatt — a javítás enélkül CSERÉLNE egy hibát egy másikra.
+     *
+     * Csak akkor ír, ha a LEVÉL scopeId eltér (no-op, ha már stimmel).
+     */
+    async backfillScopePath(id, scopePath) {
+        if (!scopePath.length) {
+            return;
+        }
+        const leafScopeId = scopePath[scopePath.length - 1].scopeId;
+        const update = { $set: { scopePath: scopePath } };
+        const filterBy = { _id: id };
+        filterBy['scopePath.scopeId'] = { $ne: leafScopeId };
+        await this.updateData({ filterBy: filterBy, update: update });
+    }
     /**
      * A `sourceFilePath` (display-relatív út) FELTÉTELES backfill-je (FAM-REV-050) — a re-scan `equal` ágán
      * hívva, hogy a default (basePath-nélküli) relatív út KONZISZTENS legyen, miután a fájl-identitás az

package/build/src/_modules/embedding/_services/fam-exact-duplicate-prune.control-service.js

@@ -0,0 +1,152 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FAM_ExactDuplicatePrune_ControlService = void 0;
+const tslib_1 = require("tslib");
+const mongoose_1 = tslib_1.__importDefault(require("mongoose"));
+const fsm_dynamo_1 = require("@futdevpro/fsm-dynamo");
+const fam_entry_data_service_1 = require("./fam-entry.data-service");
+const fam_exact_duplicate_prune_util_1 = require("../_collections/fam-exact-duplicate-prune.util");
+const fam_store_registry_const_1 = require("../_collections/fam-store-registry.const");
+const fam_vector_search_control_service_1 = require("./fam-vector-search.control-service");
+const DEFAULT_MAX_GROUPS = 50000;
+/**
+ * BÁJTAZONOS ismétlés-nyesés (2026-09-01). Azonos `(absolutePath, chunkIndex, chunkTotal, contentHash)`
+ * → a példányok között NINCS információ-különbség; a legfrissebbet tartjuk, a többit soft-delete-eljük.
+ *
+ * **Nem keverendő** a `FAM_DuplicateScan_ControlService`-szel: az SZEMANTIKAI hasonlóságot keres és
+ * sosem töröl (ott emberi ítélet kell). A kritériumok és a kivételek indoklása a pure utilban áll.
+ *
+ * A soft-delete DIREKT `_deleted` (nem `deleteData`) — a FAM entry-tárak `addArchive:true`-ok, így a
+ * per-entry törlés minden példányról ARCHÍV-másolatot csinálna (bloat + lassú tízezres nagyságrenden).
+ * Ugyanez a döntés a scope-reset ágon is (`fam-scope-maintenance.control-service.ts`).
+ */
+class FAM_ExactDuplicatePrune_ControlService {
+    static _instance;
+    static getInstance() {
+        if (!FAM_ExactDuplicatePrune_ControlService._instance) {
+            FAM_ExactDuplicatePrune_ControlService._instance = new FAM_ExactDuplicatePrune_ControlService();
+        }
+        return FAM_ExactDuplicatePrune_ControlService._instance;
+    }
+    /** A nyesés futtatása — `dryRun` esetén CSAK mér, semmit nem ír. */
+    async prune(input = {}) {
+        const dryRun = input.dryRun !== false;
+        const maxGroups = typeof input.maxGroups === 'number' && input.maxGroups > 0
+            ? Math.floor(input.maxGroups) : DEFAULT_MAX_GROUPS;
+        const targets = input.table
+            ? [fam_store_registry_const_1.FAM_StoreRegistry_Util.getEntry(input.table)].filter(Boolean)
+            : fam_store_registry_const_1.FAM_STORE_REGISTRY;
+        const tables = [];
+        for (const registryEntry of targets) {
+            const result = await this.pruneTable(registryEntry, dryRun, maxGroups);
+            if (result) {
+                tables.push(result);
+            }
+        }
+        const sum = (pick) => tables.reduce((acc, row) => acc + pick(row), 0);
+        return {
+            operation: 'prune_exact_duplicates',
+            dryRun: dryRun,
+            tables: tables,
+            totalGroups: sum((row) => row.groups),
+            totalPrunedChunks: sum((row) => row.prunedChunks),
+            totalRecallCarried: sum((row) => row.recallCarried),
+            totalSkippedSuperseded: sum((row) => row.skippedSuperseded),
+        };
+    }
+    /** Egy tár nyesése. A modell példányosítása regisztrálja a mongoose-modellt (a raw collection eléréséhez). */
+    async pruneTable(registryEntry, dryRun, maxGroups) {
+        new fam_entry_data_service_1.FAM_Entry_DataService({ dataParams: registryEntry.dataParams, issuer: 'exact-duplicate-prune' });
+        const collection = mongoose_1.default.models[registryEntry.dataParams.dataName]?.collection;
+        if (!collection) {
+            return undefined;
+        }
+        const groups = await collection.aggregate([
+            {
+                $match: {
+                    _deleted: null,
+                    'source.absolutePath': { $exists: true, $ne: null },
+                    chunkTotal: { $gt: 0 },
+                    contentHash: { $exists: true, $ne: null },
+                },
+            },
+            {
+                $group: {
+                    _id: { path: '$source.absolutePath', index: '$chunkIndex', total: '$chunkTotal', hash: '$contentHash' },
+                    count: { $sum: 1 },
+                    members: {
+                        $push: {
+                            id: '$_id',
+                            // A `__lastModified` Date — a tiszta util számot vár, ezért itt konvertáljuk (hiány → null).
+                            lastModified: { $convert: { input: '$__lastModified', to: 'long', onError: null, onNull: null } },
+                            recallCount: '$recallCount',
+                            lastRecalledAt: '$lastRecalledAt',
+                            superseded: '$superseded',
+                        },
+                    },
+                },
+            },
+            { $match: { count: { $gt: 1 } } },
+            { $limit: maxGroups + 1 },
+        ], { allowDiskUse: true }).toArray();
+        const capped = groups.length > maxGroups;
+        const work = capped ? groups.slice(0, maxGroups) : groups;
+        let prunedChunks = 0;
+        let recallCarried = 0;
+        let skippedSuperseded = 0;
+        for (const group of work) {
+            // A nyers `_id`-t megőrizzük (ObjectId VAGY string lehet) — a util string-kulcsot lát, a DB a nyerset kapja.
+            const byKey = new Map();
+            const members = group.members.map((raw) => {
+                const key = String(raw.id);
+                byKey.set(key, raw.id);
+                return {
+                    id: key,
+                    lastModified: typeof raw.lastModified === 'number' ? raw.lastModified : undefined,
+                    recallCount: raw.recallCount,
+                    lastRecalledAt: raw.lastRecalledAt,
+                    superseded: raw.superseded,
+                };
+            });
+            const plan = fam_exact_duplicate_prune_util_1.FAM_ExactDuplicatePrune_Util.planGroup(members);
+            if (typeof plan === 'string') {
+                if (plan === 'superseded-present') {
+                    skippedSuperseded++;
+                }
+                continue;
+            }
+            prunedChunks += plan.dropIds.length;
+            const hasCarry = Object.keys(plan.carry).length > 0;
+            if (hasCarry) {
+                recallCarried++;
+            }
+            if (dryRun) {
+                continue;
+            }
+            const dropRaw = plan.dropIds.map((id) => byKey.get(id));
+            await collection.updateMany({ _id: { $in: dropRaw } }, { $set: { _deleted: new Date() } });
+            if (hasCarry) {
+                // A felidézés-történet MAXIMUMA a megtartottra — az owner "amit többet használtunk, az tovább
+                // él" elve nem sérülhet attól, hogy épp a ritkábban felidézett példány a legfrissebb.
+                await collection.updateOne({ _id: byKey.get(plan.keepId) }, { $set: plan.carry });
+            }
+            for (const id of plan.dropIds) {
+                fam_vector_search_control_service_1.FAM_VectorSearch_ControlService.getInstance().removeVector(registryEntry.table, id);
+            }
+        }
+        if (capped) {
+            fsm_dynamo_1.DyFM_Log.warn(`[prune-duplicates] ${registryEntry.table}: a csoport-plafon (${maxGroups}) elerve — `
+                + 'a riport `capped: true`-t ad, tovabbi futas szukseges (nincs nema csonkolas).');
+        }
+        return {
+            table: registryEntry.table,
+            collection: collection.collectionName,
+            groups: work.length,
+            prunedChunks: prunedChunks,
+            recallCarried: recallCarried,
+            skippedSuperseded: skippedSuperseded,
+            capped: capped,
+        };
+    }
+}
+exports.FAM_ExactDuplicatePrune_ControlService = FAM_ExactDuplicatePrune_ControlService;

package/build/src/_modules/embedding/index.js

@@ -8,7 +8,7 @@
  * (BFR-AM-002/008); a bedrock-csere (MP-15) a `FAM_EmbeddingProvider` interfész mögött non-breaking.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.FAM_EmbeddingBootstrap_ControlService = exports.FAM_DupAuditScheduler_ControlService = exports.FAM_DupAudit_DataService = exports.FAM_DupAudit_ControlService = exports.FAM_DupFileRollup_Util = exports.FAM_DupForkPair_Util = exports.FAM_DupCoverage_ControlService = exports.FAM_ExactDuplication_ControlService = exports.FAM_DuplicateScan_ControlService = exports.FAM_EmbeddingCost_ControlService = exports.FAM_EmbeddingPipeline_ControlService = exports.FAM_EmbeddingPreset_ControlService = exports.FAM_StoreRegistry_Util = exports.FAM_STORE_REGISTRY = exports.FAM_DedupWarn_ControlService = exports.FAM_Entry_DataService = exports.FAM_HydrationCoordinator_ControlService = exports.FAM_VectorSearch_ControlService = exports.FAM_MOCK_EMBEDDING_DIMS = exports.FAM_Mock_EmbeddingProvider = exports.FAM_LMStudio_EmbeddingProvider = exports.FAM_OpenAI_EmbeddingProvider = exports.FAM_Embedding_ControlService = void 0;
+exports.FAM_EmbeddingBootstrap_ControlService = exports.FAM_DupAuditScheduler_ControlService = exports.FAM_DupAudit_DataService = exports.FAM_DupAudit_ControlService = exports.FAM_DupFileRollup_Util = exports.FAM_DupForkPair_Util = exports.FAM_DupCoverage_ControlService = exports.FAM_ExactDuplication_ControlService = exports.FAM_DuplicateScan_ControlService = exports.FAM_ExactDuplicatePrune_Util = exports.FAM_ExactDuplicatePrune_ControlService = exports.FAM_EmbeddingCost_ControlService = exports.FAM_EmbeddingPipeline_ControlService = exports.FAM_EmbeddingPreset_ControlService = exports.FAM_StoreRegistry_Util = exports.FAM_STORE_REGISTRY = exports.FAM_DedupWarn_ControlService = exports.FAM_Entry_DataService = exports.FAM_HydrationCoordinator_ControlService = exports.FAM_VectorSearch_ControlService = exports.FAM_MOCK_EMBEDDING_DIMS = exports.FAM_Mock_EmbeddingProvider = exports.FAM_LMStudio_EmbeddingProvider = exports.FAM_OpenAI_EmbeddingProvider = exports.FAM_Embedding_ControlService = void 0;
 // SP-2.1 — provider-dispatch kapu + providerek
 var fam_embedding_control_service_1 = require("./_services/fam-embedding.control-service");
 Object.defineProperty(exports, "FAM_Embedding_ControlService", { enumerable: true, get: function () { return fam_embedding_control_service_1.FAM_Embedding_ControlService; } });
@@ -39,6 +39,12 @@ var fam_embedding_pipeline_control_service_1 = require("./_services/fam-embeddin
 Object.defineProperty(exports, "FAM_EmbeddingPipeline_ControlService", { enumerable: true, get: function () { return fam_embedding_pipeline_control_service_1.FAM_EmbeddingPipeline_ControlService; } });
 var fam_embedding_cost_control_service_1 = require("./_services/fam-embedding-cost.control-service");
 Object.defineProperty(exports, "FAM_EmbeddingCost_ControlService", { enumerable: true, get: function () { return fam_embedding_cost_control_service_1.FAM_EmbeddingCost_ControlService; } });
+// BÁJTAZONOS ismétlés-NYESÉS (2026-09-01) — a szemantikus felderítővel ellentétben EZ töröl, de csak
+// bizonyítottan azonos tartalmat, és `dryRun` az alapértelmezés.
+var fam_exact_duplicate_prune_control_service_1 = require("./_services/fam-exact-duplicate-prune.control-service");
+Object.defineProperty(exports, "FAM_ExactDuplicatePrune_ControlService", { enumerable: true, get: function () { return fam_exact_duplicate_prune_control_service_1.FAM_ExactDuplicatePrune_ControlService; } });
+var fam_exact_duplicate_prune_util_1 = require("./_collections/fam-exact-duplicate-prune.util");
+Object.defineProperty(exports, "FAM_ExactDuplicatePrune_Util", { enumerable: true, get: function () { return fam_exact_duplicate_prune_util_1.FAM_ExactDuplicatePrune_Util; } });
 // near-duplikátum FELDERÍTŐ (read-only; user-direktíva 2026-06-21)
 var fam_duplicate_scan_control_service_1 = require("./_services/fam-duplicate-scan.control-service");
 Object.defineProperty(exports, "FAM_DuplicateScan_ControlService", { enumerable: true, get: function () { return fam_duplicate_scan_control_service_1.FAM_DuplicateScan_ControlService; } });

package/build/src/_modules/ingest/_collections/fam-project-config.util.js

@@ -0,0 +1,101 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FAM_ProjectConfig_Util = void 0;
+const tslib_1 = require("tslib");
+const fs = tslib_1.__importStar(require("fs"));
+const path = tslib_1.__importStar(require("path"));
+const fsm_dynamo_1 = require("@futdevpro/fsm-dynamo");
+/**
+ * `FAM_ProjectConfig_Util` — a **projektben látható, verziókezelt** FAM-beállítás: `.famconfig.json` a
+ * scan-gyökérben, a már bevett `.fdpfamignore` MELLETT (owner-igény 2026-08-22: „ne csak a FAM-ban éljenek
+ * ezek a beállítások", legyen kényelmesen konfigurálható és a projektben is látszódjon).
+ *
+ * **Miért a SÚLY a fő mező.** A retrieval-rangsor RELATÍV: a `finalScore` a jelöltek KÖZÖTT dönt. Ezért egy
+ * projekt EGÉSZÉRE adott, egyenletes súly-szorzó pontosan azt csinálja, amit az owner kért:
+ *  - **általános keresésben** (a projekt más projektekkel VERSENYZIK) a tartalma halkabban jelenik meg;
+ *  - **célzott keresésben** (`scopeFilter` az adott projektre) MINDEN jelölt ugyanazt a szorzót kapja,
+ *    így a sorrend VÁLTOZATLAN — a projekt a saját keresésében teljes értékű marad.
+ * Nem kell tehát külön „általános vs. célzott" mechanika: az egyenletes szorzó önmagában elvégzi.
+ *
+ * A `weight: 0` és a negatív érték SZÁNDÉKOSAN tiltott: a `finalScore = score × weight` miatt az a bejegyzést
+ * VÉGLEG visszakereshetetlenné tenné (2026-08-22-én mérve a `write` oldalán — az entry a saját egyedi
+ * markerére sem jött vissza). Aki ki akar zárni valamit, `.fdpfamignore`-t írjon: az a szándék helyes kifejezése.
+ */
+class FAM_ProjectConfig_Util {
+    /** A projekt-konfig fájlneve — a `.fdpfamignore` testvére, ugyanabban a gyökérben. */
+    static FILE_NAME = '.famconfig.json';
+    /** Catch-all glob a projekt-szintű súlyhoz (a `weights` specifikus mintái ELÉBE kerülnek). */
+    static CATCH_ALL = '**';
+    /**
+     * A `.famconfig.json` beolvasása a megadott gyökérből. Hiányzó fájl → `undefined` (teljesen opcionális).
+     * Hibás JSON / érvénytelen érték → **WARN + a hibás mező kihagyása**, SOHA nem dönti meg a scant: egy
+     * elgépelt konfig ne akadályozza meg a projekt indexelését (`core-rich-error-handling`).
+     */
+    static load(rootDir) {
+        const file = path.join(rootDir, FAM_ProjectConfig_Util.FILE_NAME);
+        if (!fs.existsSync(file)) {
+            return undefined;
+        }
+        let raw;
+        try {
+            raw = JSON.parse(fs.readFileSync(file, 'utf8'));
+        }
+        catch (error) {
+            fsm_dynamo_1.DyFM_Log.warn(`[FAM scan] '${file}' NEM értelmezhető JSON (${error?.message}) — a projekt-konfig `
+                + 'KIHAGYVA, a scan a default beállításokkal folytatódik.');
+            return undefined;
+        }
+        const parsed = (raw && typeof raw === 'object') ? raw : {};
+        const config = {};
+        const weight = parsed.weight;
+        if (weight !== undefined) {
+            if (typeof weight === 'number' && Number.isFinite(weight) && weight > 0) {
+                config.weight = weight;
+            }
+            else {
+                fsm_dynamo_1.DyFM_Log.warn(`[FAM scan] '${file}': a \`weight\` POZITÍV szám kell legyen (kapott: ${String(weight)}) — `
+                    + 'kihagyva. A 0/negatív súly visszakereshetetlenné tenné a projektet; kizáráshoz `.fdpfamignore` kell.');
+            }
+        }
+        const weights = parsed.weights;
+        if (Array.isArray(weights)) {
+            const valid = weights.filter((rule) => !!rule && typeof rule === 'object'
+                && typeof rule.pattern === 'string'
+                && typeof rule.weight === 'number'
+                && Number.isFinite(rule.weight)
+                && rule.weight > 0);
+            if (valid.length !== weights.length) {
+                fsm_dynamo_1.DyFM_Log.warn(`[FAM scan] '${file}': ${weights.length - valid.length} érvénytelen \`weights\` szabály `
+                    + 'kihagyva (kell: `pattern` string + POZITÍV `weight`).');
+            }
+            if (valid.length) {
+                config.weights = valid;
+            }
+        }
+        if (typeof parsed.note === 'string') {
+            config.note = parsed.note;
+        }
+        return (config.weight !== undefined || config.weights || config.note) ? config : undefined;
+    }
+    /**
+     * A PROJEKT-FAKTOR szabálylistája (a temperálatlan `projectWeight`-hez). Az első illeszkedő nyer, ezért a
+     * sorrend jelentéses: ① a konfig SPECIFIKUS mintái, ② a projekt-szintű `weight` catch-all glob-ként — így
+     * egy `{"pattern": "__documentations/**", "weight": 1.0}` kivétel TÉNYLEGESEN kiveszi a doksikat a halkítás alól.
+     *
+     * ⚠️ KÜLÖN CSATORNA a hívó `weights`-étől. A hívó (scan-API) szabályai a `weight` mezőre mennek, ami a
+     * retrieval `effectiveWeight` temperálásán át hat (0.06 influence → max 6%). A projekt-konfig szabályai ide
+     * jönnek, ahol a szorzó KÖZVETLEN. A kettő összekeverése azt jelentené, hogy a `.famconfig.json`-ban felvett
+     * kivétel némán hatástalan marad — pontosan az a fajta látszat-funkció, amit kerülni akarunk.
+     */
+    static projectWeightRules(config) {
+        if (!config) {
+            return undefined;
+        }
+        const rules = [...(config.weights ?? [])];
+        if (config.weight !== undefined) {
+            rules.push({ pattern: FAM_ProjectConfig_Util.CATCH_ALL, weight: config.weight });
+        }
+        return rules.length ? rules : undefined;
+    }
+}
+exports.FAM_ProjectConfig_Util = FAM_ProjectConfig_Util;