@futdevpro/fdp-agent-memory 1.1.166 → 1.1.194

package/build/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@futdevpro/fdp-agent-memory",
-    "version": "1.1.166",
+    "version": "1.1.194",
     "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/_commands/retire-temporary.command.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FAM_RetireTemporary_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 retire-temporary [--apply]` — az alvó beszélgetés-törmelék nyugdíjazása a `memory` táron.
+ *
+ * A szabály (v2, owner: „javítsd, amit kell" — 2026-09-02): törmelék-osztály (`user_prompt` /
+ * `temporary_context`) ÉS 30+ napos → `superseded + retiredAt`, a felidézés-számtól FÜGGETLENÜL (mérve:
+ * a recallCount ezen az osztályon öngerjesztő rangsor-kitettséget mért — a csúcs-„felidézett" egy
+ * task-notification XML-blokk volt recall=281-gyel). **NEM törlés** — a tartalom és a vektor marad, a
+ * rangsor-büntetés süllyeszti, a cold-search megtalálja. **Alapértelmezés a DRY-RUN** — `--apply` kell.
+ *
+ * A heti scan-scheduler automatikusan is futtatja (`memory.retireTemporaryEnabled`); ez a parancs a
+ * kézi/azonnali út + a dry-run előnézet.
+ */
+class FAM_RetireTemporary_Util {
+    /** A `retire-temporary` parancs-deszkriptor. */
+    static command() {
+        const command = new commander_1.Command('retire-temporary');
+        command
+            .description('Az alvó törmelék (user_prompt/temporary_context) nyugdíjazása (DRY-RUN az alapértelmezés)')
+            .option('--apply', 'a nyugdíjazás TÉNYLEGES végrehajtása (enélkül csak mér, nem ír)')
+            .option('--after-days <n>', 'a korhatár felülírása erre a futásra (default: config, 30 nap)')
+            .action(async () => {
+            fam_output_util_1.FAM_Output_Util.exit(await FAM_RetireTemporary_Util.run(command));
+        });
+        return command;
+    }
+    /** A `retire-temporary` futtatása a REST `POST /api/memory/retire-temporary`-n. */
+    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 afterDays = local.afterDays !== undefined ? Number(local.afterDays) : undefined;
+        const result = await client.post('/api/memory/retire-temporary', {
+            // A `--apply` HIÁNYA a biztonságos irány: dryRun marad. Elgépelt kapcsoló sosem nyugdíjaz.
+            dryRun: local.apply !== true,
+            retireAfterDays: Number.isFinite(afterDays) ? afterDays : undefined,
+        });
+        if (!result.ok) {
+            return fam_output_util_1.FAM_Output_Util.failure({
+                options: globals,
+                command: 'retire-temporary',
+                error: result.error ?? { errorCode: 'FAM-CLI-RETIRE-001', message: 'Ismeretlen retenció-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: 'retire-temporary',
+            data: result.data,
+            humanFormatter: (data) => FAM_RetireTemporary_Util.format(data),
+        });
+    }
+    /** Ember-olvasható összegzés — a MEGTARTÁS okai is látszanak (a védelem is jelentendő tény). */
+    static format(report) {
+        const lines = [];
+        lines.push(report.dryRun
+            ? `Memória-retenció — DRY-RUN (semmi nem változott; végrehajtás: --apply; korhatár ${report.retireAfterDays} nap):`
+            : `Memória-retenció — VÉGREHAJTVA (korhatár ${report.retireAfterDays} nap):`);
+        lines.push(`  vizsgált törmelék-jelölt: ${report.scanned}`);
+        lines.push(`  nyugdíjazva:              ${report.retired}  (superseded+retiredAt — NEM törlés, hidegen kereshető)`);
+        lines.push(`  MEGTARTVA — még fiatal:   ${report.keptTooYoung}`);
+        if (report.alreadySuperseded) {
+            lines.push(`  már korábban nyugdíjas:   ${report.alreadySuperseded}`);
+        }
+        if (!report.scanned) {
+            lines.push('  ✓ nincs törmelék-jelölt a memory táron.');
+        }
+        return lines.join('\n');
+    }
+}
+exports.FAM_RetireTemporary_Util = FAM_RetireTemporary_Util;

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

@@ -8,6 +8,8 @@ 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 retire_temporary_command_1 = require("./_commands/retire-temporary.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 +58,8 @@ 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(),
+        retire_temporary_command_1.FAM_RetireTemporary_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

@@ -187,6 +187,66 @@ 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.
+    // SZO SZERINTI IDEZET-MENTES (2026-09-02, black-box lelet). A bemasolt hibauzenet/idezet chunkja BE SEM
+    // KERUL a vektor-jeloltek koze (merve: 60 talalatbol 0 tartalmazta a keresett stringet) — ez recall-hiba.
+    // A mentes a FEAT-003 kod-expanzio mintajara determinisztikusan behozza a szo szerint egyezo entry-ket.
+    'read.literalRescueEnabled': {
+        type: 'boolean', default: true, levels: ALL_LEVELS,
+        description: 'Szo szerinti idezet-mentes: ha a query IDEZET-SZERU (>=5 token, van benne disztinktiv '
+            + 'token), a pontosan egyezo entry-k a vektor-uton KIVUL is bekerulnek. A talalati lista tobbi '
+            + 'eleme valtozatlan marad.',
+    },
+    'read.literalRescueMaxDocs': {
+        type: 'number', default: 10000, min: 0, max: 1000000, integer: true, levels: ALL_LEVELS,
+        description: 'MERET-KAPU: a mentes csak ennyi dokumentumnal kisebb taron fut (a content-substring NEM '
+            + 'indexelheto -> collection-scan). MERVE 2026-09-02: rules 296 ms · coding_patterns 504 ms · '
+            + 'knowledge 2,1 s · memory 4,9 s · documents 13,1 s · codebase 45,2 s. A default 10000 a rules-t '
+            + 'es a coding_patterns-t engedi be (~0,8 s legrosszabb eset), a tobbit KIHAGYJA — a mentes soha '
+            + 'nem tehet egy olvasast masodperces muvellette.',
+    },
+    'read.literalRescueLimit': {
+        type: 'number', default: 10, min: 1, max: 100, integer: true, levels: ALL_LEVELS,
+        description: 'Hany mentett entry kerulhet be tarankent (a talalati lista nem arasztodhat el).',
+    },
+    '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.crossTableNoteProbeTables': {
+        type: 'string', default: 'memory', levels: ALL_LEVELS,
+        description: 'A szondazott tarak (vesszo-szeparalt; ervenyes: memory, knowledge). Default CSAK memory — '
+            + 'MERVE (2026-09-02): a 44 esetes benchmark 21 szonda-jeloltjebol MIND a memory tarbol jott, a '
+            + 'knowledge 0-t adott (a talalatai a tormelek-szures utan mind kiestek), mikozben a szondaja a '
+            + 'wall-clock koltseg ~felet vitte (a ket pool-koszinusz a Node-szalon sorosodik). A knowledge '
+            + 'visszakapcsolhato: "memory,knowledge".',
+    },
+    '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-
@@ -329,6 +389,21 @@ exports.CONFIG_CATALOG = {
         description: 'A cold-search dormant-scan FELSŐ KORLÁTJA (biztonsági memóriakorlát, dsgn-013 §5.3): a Mongo-koszinusz '
             + 'legfeljebb ennyi dormant entry vektorát tölti be egy keresésnél. Default 5000.',
     },
+    // RETENCIO (2026-09-02): az alvo beszelgetes-tormelek (user_prompt / temporary_context) heti
+    // nyugdijazasa. Merve: 8 717 ilyen bejegyzes (a memory tar 20,2%-a) egy egyszeri importbol, 98,2%-uk
+    // SOHA nem lett felidezve — megis teljes sullyal versenyeztek a gondozott jegyzetekkel. A nyugdij
+    // NEM torles: superseded+retiredAt, a supersededPenalty sullyeszti, a cold-search megtalalja.
+    'memory.retireTemporaryEnabled': {
+        type: 'boolean', default: true, levels: ALL_LEVELS,
+        description: 'A heti automatikus retencio kapcsoloja: a scan-scheduler a heti re-scan UTAN nyugdijazza '
+            + 'az alvo tormelek-bejegyzeseket. A szabaly: tormelek-osztaly ES sosem felidezett ES 30+ napos. '
+            + 'A valaha felidezett bejegyzes OROKRE aktiv marad ("amit tobbet hasznaltunk, az tovabb el").',
+    },
+    'memory.retireTemporaryAfterDays': {
+        type: 'number', default: 30, min: 1, max: 3650, integer: true, levels: ALL_LEVELS,
+        description: 'Hany nap utan nyugdijazhato a SOSEM felidezett tormelek-bejegyzes. A friss kontextusnak '
+            + 'igy van eselye felidezodni, mielott a retencio eleri.',
+    },
     'memory.supersededPenalty': {
         type: 'number', default: 0.25, min: 0, max: 1, levels: ALL_LEVELS,
         description: 'A LEVÁLTOTT (superseded) memória ranking-PENALTYje (dsgn-013 §6): egy additív memory-fájl régi, már '

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

@@ -86,6 +86,12 @@ class FAM_Entry extends fsm_dynamo_1.DyFM_Metadata {
      * (`memory.supersededPenalty`), így a friss verzió fölébe kerül. A content-addressed additív delta jelöli.
      */
     superseded;
+    /**
+     * MIKOR vonult nyugdíjba (retenció, 2026-09-02): a `superseded`-re váltás időbélyege (epoch ms), ha azt
+     * NEM a tartalom-leváltás, hanem a retenció vagy a memory-táras write-delete adta. Auditálhatóság: ebből
+     * látszik, hogy a bejegyzés MIÉRT hideg — leváltották vagy nyugdíjazták. Hiánya = tartalom-leváltás.
+     */
+    retiredAt;
     // --- forrás / pozíció (scan/import esetén) ---
     /** Provenance (dsgn-001 §6). */
     source;

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

@@ -56,5 +56,8 @@ exports.famMemory_dataParams = new fsm_dynamo_1.DyFM_DataModel_Params({
         recallCount: { type: 'number', default: 0 },
         dormant: { type: 'boolean', index: true },
         superseded: { type: 'boolean', index: true },
+        // Retenció (2026-09-02): a nyugdíjazás időbélyege — ebből látszik, hogy a bejegyzés MIÉRT hideg
+        // (nyugdíjazták vs a tartalmát leváltották). Az utóbbi esetben hiányzik.
+        retiredAt: { type: 'number' },
     },
 });

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-embedding-bootstrap.control-service.js

@@ -1,6 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FAM_EmbeddingBootstrap_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 config_control_service_1 = require("../../../_routes/server/config/config.control-service");
 const fam_dup_audit_scheduler_control_service_1 = require("./fam-dup-audit-scheduler.control-service");
@@ -10,6 +12,8 @@ const fam_scope_maintenance_control_service_1 = require("../../scope-reference/_
 const fam_scan_job_control_service_1 = require("../../ingest/_services/fam-scan-job.control-service");
 const fam_scan_scheduler_control_service_1 = require("../../ingest/_services/fam-scan-scheduler.control-service");
 const fam_memory_dormancy_control_service_1 = require("../../retrieval/_services/fam-memory-dormancy.control-service");
+const fam_store_registry_const_1 = require("../_collections/fam-store-registry.const");
+const fam_entry_data_service_1 = require("./fam-entry.data-service");
 /**
  * `FAM_EmbeddingBootstrap_ControlService` (SP-2.2/2.4) — az embedding + vektor-réteg **boot-hook**-ja.
  * Az `App.postProcess()` (a DB-connect + setup UTÁNI hook) hívja. Két lépés:
@@ -65,6 +69,11 @@ class FAM_EmbeddingBootstrap_ControlService {
         catch (error) {
             fsm_dynamo_1.DyFM_Log.warn(`[FAM bootstrap] dup-őrjárat scheduler telepítése sikertelen: ${error?.message}`);
         }
+        // TELJESÍTMÉNY-INDEXEK (2026-09-02, mért incidens): a `/stats` (és minden `__lastModified`-sort /
+        // `_deleted`-szűrt / scope-count lekérdezés) COLLSCAN volt — meleg Mongo-cache mellett észrevétlen,
+        // kihűlt cache + telített lemezen viszont 20–50 s/tár, a UI landing PERCEKIG lógott. A createIndex
+        // idempotens (létező indexre no-op); háttérben fut, a boot nem várja be (fire-and-forget, WARN-nal).
+        void this.ensurePerformanceIndexes();
         // A readiness-coordinator hidratálás-bevárás time-outja a `read.hydrationWaitMs` config-ból (a hidratálás
         // ELŐTT, hogy a `beginBoot` után érkező read-ek már a helyes időkorláttal várjanak). Best-effort (default 180s).
         try {
@@ -122,5 +131,28 @@ class FAM_EmbeddingBootstrap_ControlService {
             fsm_dynamo_1.DyFM_Log.warn(`[FAM bootstrap] memory-dormancy sweep sikertelen: ${error?.message}`);
         }
     }
+    /**
+     * A mért lassú lekérdezés-alakok indexei MINDEN entry-táron (2026-09-02): `__lastModified` (a stats
+     * "utolsó módosítás" sort-ja), `_deleted` (az aktív-szűrős countok), `scopePath.scopeId` (a scope-countok
+     * és a delta-compare scope-szűrője). Idempotens; a hiba WARN — az index-hiány lassulás, nem leállás.
+     */
+    async ensurePerformanceIndexes() {
+        for (const registryEntry of fam_store_registry_const_1.FAM_STORE_REGISTRY) {
+            try {
+                new fam_entry_data_service_1.FAM_Entry_DataService({ dataParams: registryEntry.dataParams, issuer: 'boot-indexes' });
+                const collection = mongoose_1.default.models[registryEntry.dataParams.dataName]?.collection;
+                if (!collection) {
+                    continue;
+                }
+                await collection.createIndex({ __lastModified: -1 });
+                await collection.createIndex({ _deleted: 1 });
+                await collection.createIndex({ 'scopePath.scopeId': 1 });
+            }
+            catch (error) {
+                fsm_dynamo_1.DyFM_Log.warn(`[FAM bootstrap] teljesítmény-index kiépítés sikertelen (${registryEntry.table}): `
+                    + `${error?.message}`);
+            }
+        }
+    }
 }
 exports.FAM_EmbeddingBootstrap_ControlService = FAM_EmbeddingBootstrap_ControlService;

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;