@futdevpro/fdp-agent-memory 1.1.177 → 1.1.194

package/build/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@futdevpro/fdp-agent-memory",
-    "version": "1.1.177",
+    "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": {

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

@@ -9,6 +9,7 @@ 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");
@@ -58,6 +59,7 @@ function registerFAMCommands(program, version) {
         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

@@ -191,6 +191,27 @@ exports.CONFIG_CATALOG = {
     // 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, '
@@ -213,6 +234,14 @@ exports.CONFIG_CATALOG = {
         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 — '
@@ -360,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/_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/ingest/_services/fam-scan-scheduler.control-service.js

@@ -4,6 +4,7 @@ exports.FAM_ScanScheduler_ControlService = void 0;
 const fsm_dynamo_1 = require("@futdevpro/fsm-dynamo");
 const fam_config_level_type_enum_1 = require("../../../_enums/fam-config-level.type-enum");
 const config_control_service_1 = require("../../../_routes/server/config/config.control-service");
+const retrieval_1 = require("../../retrieval");
 const fam_scan_job_control_service_1 = require("./fam-scan-job.control-service");
 const fam_scan_job_data_service_1 = require("./fam-scan-job.data-service");
 const embedding_1 = require("../../embedding");
@@ -120,6 +121,10 @@ class FAM_ScanScheduler_ControlService {
                 + `(slot: ${FAM_ScanScheduler_ControlService.DAY_NAMES[day] ?? day} ${hour}:00). Indítás…`);
             await this.markRan(config, nowMs);
             await this.triggerRescan();
+            // RETENCIÓ (2026-09-02): a heti ütemben az alvó törmelék nyugdíjazása is fut — a lényege az
+            // automatizmus (különben a törmelék sosem vonul nyugdíjba). A scan-tól FÜGGETLEN munka, nem
+            // várja meg (a scan async, waitMs:0); best-effort: a hibája nem buktatja a ticket.
+            await this.runWeeklyRetention();
         }
         catch (error) {
             fsm_dynamo_1.DyFM_Log.warn(`[FAM scanScheduler] heti re-scan tick sikertelen (best-effort): ${error?.message}`);
@@ -128,6 +133,27 @@ class FAM_ScanScheduler_ControlService {
             this.ticking = false;
         }
     }
+    /**
+     * A heti retenció: az alvó törmelék (`user_prompt`/`temporary_context`, sosem felidézett, 30+ napos)
+     * nyugdíjazása. Kapu: `memory.retireTemporaryEnabled` (default true). A szabály + indoklás:
+     * `retrieval/_collections/fam-memory-retention.util.ts`. Best-effort — a hiba WARN, nem tick-bukás.
+     */
+    async runWeeklyRetention() {
+        try {
+            const retention = retrieval_1.FAM_MemoryRetention_ControlService.getInstance();
+            if (!(await retention.isAutoEnabled())) {
+                fsm_dynamo_1.DyFM_Log.log('[FAM scanScheduler] heti retenció KIKAPCSOLVA (`memory.retireTemporaryEnabled=false`) — kihagyva.');
+                return;
+            }
+            const report = await retention.retire({ dryRun: false });
+            fsm_dynamo_1.DyFM_Log.log(`[FAM scanScheduler] heti retenció kész: ${report.retired} nyugdíjazva `
+                + `(${report.scanned} jelöltből; ${report.keptTooYoung} még fiatal, `
+                + `${report.alreadySuperseded} már nyugdíjas).`);
+        }
+        catch (error) {
+            fsm_dynamo_1.DyFM_Log.warn(`[FAM scanScheduler] heti retenció sikertelen (best-effort): ${error?.message}`);
+        }
+    }
     /** A TELJES re-scan indítása: `scan.weeklyRescanRoot` (ha van) VAGY a legutóbbi durable scan-job cél-specjei. */
     async triggerRescan() {
         const origin = { agent: 'fam-scheduler', label: 'weekly-rescan' };

package/build/src/_modules/mcp/_collections/fam-core-tools.const.js

@@ -66,6 +66,11 @@ const READ_INPUT_SCHEMA = {
                         description: 'Feltárás-mélység: `deep` → mély feltárás (sokkal több chunk; a `read.deepTopK` '
                             + 'az alap topK helyett). Default `normal`. Az explicit `topK` mindig felülír.',
                     },
+                    skipReactivation: {
+                        type: 'boolean',
+                        description: 'DIAGNOSZTIKA: a visszaadott memory-hitek NE kapjanak felidézés-megerősítést '
+                            + '(recallCount++). Mérő-/kalibrációs forgalomhoz — a mérés nem terhelheti a mért rendszert.',
+                    },
                     includeCrossTableProbe: {
                         type: 'boolean',
                         description: 'DIAGNOSZTIKA (nem termék-funkció): a kereszt-tár szonda nyers döntési adata '

package/build/src/_modules/mcp/_services/fam-read-tool.service.js

@@ -320,6 +320,7 @@ class FAM_ReadTool_Service {
             excludeIds: query.excludeIds,
             depth: query.depth,
             includeCrossTableProbe: query.includeCrossTableProbe,
+            skipReactivation: query.skipReactivation,
             // Per-query tartalom-kapcsolo atvezetese (2026-08-14 lelet: eddig itt VESZETT EL).
             includeContent: query.includeContent,
         };

package/build/src/_modules/mcp/_services/fam-write-tool.service.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FAM_WriteTool_Service = void 0;
 const fsm_dynamo_1 = require("@futdevpro/fsm-dynamo");
+const fam_table_type_enum_1 = require("../../../_enums/fam-table.type-enum");
 const error_codes_const_1 = require("../../../_collections/error-codes.const");
 const fam_error_factory_util_1 = require("../../../_collections/fam-error-factory.util");
 const fam_entry_data_model_1 = require("../../../_models/data-models/fam-entry.data-model");
@@ -333,19 +334,40 @@ class FAM_WriteTool_Service {
         // FAM-REV-051 bulk: `sourceFilePath`/`absolutePath` → egy fájl ÖSSZES chunkja; `id`/`query` → egyetlen.
         const targets = await this.resolveDeleteTargets(input, dataService, 'write-delete');
         const deletedIds = [];
+        // RETIRE-NOT-DELETE a `memory` táron (2026-09-02, owner-elv: „nem baj, ha fennmarad olyan memória,
+        // amit a Claude már elfelejtett — sőt!"). A memória-törlés NYUGDÍJAZÁS: `superseded + retiredAt`,
+        // a tartalom és a vektor marad (a penalty süllyeszti, a cold-search megtalálja). Más táron a
+        // viselkedés VÁLTOZATLAN — ott a fájl az igazság, a scan a törölt chunkot úgyis újra behozná.
+        // Valódi hard-delete-re a scope-maintenance reset az admin-út.
+        const retireInsteadOfDelete = input.table === fam_table_type_enum_1.FAM_Table.memory;
+        const now = Date.now();
         for (const entry of targets) {
             if (!entry._id) {
                 continue;
             }
-            // absolute=false → soft-delete (Dynamo-konvenció: `_deleted` marker, archív collection).
-            await dataService.deleteData(entry._id, false);
-            // Pool-coherence (FAM-REV-046): a törölt vektort a hívó-process in-memory LVS-pool-jából is kivesszük.
-            embedding_1.FAM_VectorSearch_ControlService.getInstance().removeVector(input.table, entry._id);
+            if (retireInsteadOfDelete) {
+                await dataService.updateData({
+                    filterBy: { _id: entry._id },
+                    update: { $set: { superseded: true, retiredAt: now } },
+                });
+                // A vektor a poolban MARAD — a superseded-szemantika része (a rangsor-büntetés süllyeszti).
+            }
+            else {
+                // absolute=false → soft-delete (Dynamo-konvenció: `_deleted` marker, archív collection).
+                await dataService.deleteData(entry._id, false);
+                // Pool-coherence (FAM-REV-046): a törölt vektort a hívó-process in-memory LVS-pool-jából is kivesszük.
+                embedding_1.FAM_VectorSearch_ControlService.getInstance().removeVector(input.table, entry._id);
+            }
             deletedIds.push(entry._id);
         }
-        const warnings = deletedIds.length > 1
-            ? [`Bulk file-delete: ${deletedIds.length} chunk soft-delete-elve (cél: ${input.target?.by}='${input.target?.value}').`]
-            : [];
+        const warnings = [];
+        if (retireInsteadOfDelete && deletedIds.length) {
+            warnings.push(`A memory táron a törlés NYUGDÍJAZÁS: ${deletedIds.length} bejegyzés superseded+retiredAt `
+                + 'jelölést kapott — hidegen kereshető marad, nem törlődött (owner-elv: a felejtett memória is érték).');
+        }
+        else if (deletedIds.length > 1) {
+            warnings.push(`Bulk file-delete: ${deletedIds.length} chunk soft-delete-elve (cél: ${input.target?.by}='${input.target?.value}').`);
+        }
         return this.baseOutput({
             operation: input.operation, table: input.table,
             scopePath: (targets[0]?.scopePath ?? []),

package/build/src/_modules/retrieval/_collections/fam-cross-table-note.util.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FAM_CrossTableNote_Util = void 0;
+const fam_memory_retention_util_1 = require("./fam-memory-retention.util");
 /**
  * NEM-TUDÁS jelöltek: nyers beszélgetés-törmelék, amivel SOHA nem szabad „mellesleg"-et adni.
  *
@@ -14,8 +15,11 @@ exports.FAM_CrossTableNote_Util = void 0;
  * összefoglalója. A benchmarkban pont a döntési zónában ült (+0,022), és semmilyen kérdésre nem válasz.
  * (A scan-summary zaja külön is mért, ismert probléma — `reference_fam_scan_summary_weight_cap`.)
  */
-const NON_KNOWLEDGE_KINDS = ['user_prompt', 'fs-summary'];
-const NON_KNOWLEDGE_TAGS = ['temporary_context', 'scan-summary'];
+// A MEMORIA-tormelek definicioja a KOZOS utilbol jon (fam-memory-retention.util) — egy definicio,
+// harom felhasznalas (retencio + reaktivacio-szuro + kereszt-tar szonda). Itt CSAK a knowledge-tar
+// sajat zaja (fs-summary/scan-summary) egeszul ki.
+const NON_KNOWLEDGE_KINDS = ['fs-summary'];
+const NON_KNOWLEDGE_TAGS = ['scan-summary'];
 class FAM_CrossTableNote_Util {
     /**
      * A döntés. `undefined` = **csend**: nincs mező a válaszban. Szándékosan NEM adunk „nem találtam
@@ -56,8 +60,11 @@ class FAM_CrossTableNote_Util {
             }),
         };
     }
-    /** Beszélgetés-törmelék-e a jelölt (nyers user-prompt / átmeneti kontextus). Lásd a fenti mérést. */
+    /** Beszélgetés-törmelék / gépi zaj-e a jelölt. A memória-törmelék részt a közös util dönti el. */
     static isNonKnowledge(candidate) {
+        if (fam_memory_retention_util_1.FAM_MemoryRetention_Util.isDebris({ kind: candidate.kind, tags: candidate.tags })) {
+            return true;
+        }
         if (candidate.kind && NON_KNOWLEDGE_KINDS.includes(candidate.kind)) {
             return true;
         }

package/build/src/_modules/retrieval/_collections/fam-lexical-match.util.js

@@ -31,6 +31,25 @@ class FAM_LexicalMatch_Util {
     ];
     /** A tő MINIMÁLIS hossza tövezés után (a túl-tövezés hamis egyezéseket hozna). */
     static MIN_STEM_LEN = 4;
+    /**
+     * SZÓ SZERINTI IDÉZET-EGYEZÉS (2026-09-02, black-box futás lelete). A term-átfedés egy HALMAZ-arány:
+     * nem tudja megkülönböztetni a „ugyanazok a szavak szétszórva" esetet a „pontosan ez a mondat van benne"
+     * esettől — pedig az utóbbi nagyságrenddel erősebb relevancia-jel.
+     *
+     * **Mért eset:** a `402 Payment Required - You must sign up for private packages` hibaüzenet szó szerinti
+     * bemásolása (a legtermészetesebb fejlesztői reflex) a `fdp-never-public-packages` szabályt a **#7**
+     * helyre tette 60 találatból — holott a szabály-fájl **literálisan tartalmazza ezt a mondatot**, és övé
+     * volt a mezőny LEGMAGASABB term-átfedése (0,325). A nyers koszinusza viszont csak 0,480 volt (egy
+     * kontextus nélküli hibaüzenet gyenge szemantikus jel), és a ×1,195-ös boost nem hozta fel.
+     *
+     * A phrase-bónusz ezt a hibaosztályt fedi — bemásolt hibaüzenet, idézett mondat, pontos azonosító —, és
+     * a PARAFRAZEÁLT kérdéseket NEM érinti: ott nincs hosszú, szó szerinti egyezés, tehát nincs bónusz sem.
+     */
+    static MIN_PHRASE_LEN = 3;
+    /** A phrase-bónusz maximuma (a teljes query-hossznyi szó szerinti egyezésre jár). */
+    static PHRASE_BONUS = 0.6;
+    /** A vizsgált query-tokenek plafonja — egy hosszú prompt ne csináljon O(n²) munkát hit-enként. */
+    static MAX_PHRASE_TOKENS = 24;
     /** Tokenizálás: kisbetűsít, nem-alfanumerikuson tör, stopword + rövid token kihagyva, DEDUP (Set). */
     static tokenize(text) {
         const terms = new Set();
@@ -62,12 +81,53 @@ class FAM_LexicalMatch_Util {
         }
         return undefined;
     }
+    /**
+     * NYERS, SORRENDHELYES token-sorozat (a phrase-egyezéshez). A `tokenize`-zal ellentétben **NEM** szűr
+     * stopwordöt és **NEM** dedupál: a szó szerinti idézetben a kötőszavak is a mondat részei — pont azok
+     * teszik idézetté. A rövid tokenek (`MIN_TOKEN_LEN` alatt) itt is kimaradnak, mert a normalizált
+     * szövegben sem szerepelnek.
+     */
+    static tokenizeSequence(text) {
+        if (!text) {
+            return [];
+        }
+        return text.toLowerCase()
+            .split(/[^a-z0-9áéíóöőúüű]+/)
+            .filter((token) => token.length >= FAM_LexicalMatch_Util.MIN_TOKEN_LEN);
+    }
+    /** Az entry kereshető szövegének normalizált alakja (kisbetűs, egy-szóközös) — a phrase-kereséshez. */
+    static normalizeForPhrase(text) {
+        if (!text) {
+            return '';
+        }
+        return ` ${text.toLowerCase().split(/[^a-z0-9áéíóöőúüű]+/).filter(Boolean).join(' ')} `;
+    }
+    /**
+     * A leghosszabb SZÓ SZERINTI, összefüggő query-részlet hossza, ami az entry szövegében is megvan
+     * (0, ha nincs `MIN_PHRASE_LEN`-nél hosszabb egyezés). A leghosszabb ablaktól indul és az ELSŐ
+     * egyezésnél visszatér — így a tipikus „nincs idézet" eset is korlátos munkával zárul.
+     */
+    static longestPhraseRun(queryTokens, normalizedEntryText) {
+        const tokens = queryTokens.slice(0, FAM_LexicalMatch_Util.MAX_PHRASE_TOKENS);
+        if (tokens.length < FAM_LexicalMatch_Util.MIN_PHRASE_LEN || !normalizedEntryText) {
+            return 0;
+        }
+        for (let length = tokens.length; length >= FAM_LexicalMatch_Util.MIN_PHRASE_LEN; length--) {
+            for (let start = 0; start + length <= tokens.length; start++) {
+                const phrase = ` ${tokens.slice(start, start + length).join(' ')} `;
+                if (normalizedEntryText.includes(phrase)) {
+                    return length;
+                }
+            }
+        }
+        return 0;
+    }
     /**
      * Lexikai átfedés-score (0..1): a `queryTerms` hányad része van jelen az entry kereshető szövegében.
      * `content`-egyezés = base-átfedés; `headingPath`/`sourceFilePath`-egyezés = + `TITLE_PATH_BONUS` súly (1-re vágva).
      * Üres query-term-halmaz → 0 (nincs jel → nincs boost). PURE.
      */
-    static score(queryTerms, entry) {
+    static score(queryTerms, entry, queryPhraseTokens) {
         if (!queryTerms.size) {
             return 0;
         }
@@ -94,7 +154,20 @@ class FAM_LexicalMatch_Util {
         const total = queryTerms.size;
         const base = baseMatched / total;
         const titleBonus = (titleMatched / total) * FAM_LexicalMatch_Util.TITLE_PATH_BONUS;
-        return Math.min(1, base + titleBonus);
+        // SZÓ SZERINTI IDÉZET-BÓNUSZ: a query hány százaléka szerepel ÖSSZEFÜGGŐEN, szó szerint az entry
+        // szövegében. A halmaz-átfedés ezt nem látja (neki a szórt egyezés ugyanannyi) — pedig egy bemásolt
+        // hibaüzenet vagy idézett mondat majdnem biztos relevancia-jel. Az indoklás + a mért eset a
+        // `MIN_PHRASE_LEN` konstans doc-commentjében.
+        let phraseBonus = 0;
+        if (queryPhraseTokens && queryPhraseTokens.length) {
+            const searchable = FAM_LexicalMatch_Util.normalizeForPhrase(`${entry.content ?? ''} ${(entry.headingPath ?? []).join(' ')} ${entry.sourceFilePath ?? ''}`);
+            const run = FAM_LexicalMatch_Util.longestPhraseRun(queryPhraseTokens, searchable);
+            if (run > 0) {
+                const considered = Math.min(queryPhraseTokens.length, FAM_LexicalMatch_Util.MAX_PHRASE_TOKENS);
+                phraseBonus = FAM_LexicalMatch_Util.PHRASE_BONUS * (run / considered);
+            }
+        }
+        return Math.min(1, base + titleBonus + phraseBonus);
     }
 }
 exports.FAM_LexicalMatch_Util = FAM_LexicalMatch_Util;

package/build/src/_modules/retrieval/_collections/fam-literal-phrase.util.js

@@ -0,0 +1,74 @@
+"use strict";
+/**
+ * SZÓ SZERINTI IDÉZET-MENTÉS — a döntés, hogy egy query megéri-e a pontos szöveg-keresést (2026-09-02).
+ *
+ * **A mért hiba.** A black-box futás leletét külön ellenőrizve: a
+ * `402 Payment Required - You must sign up for private packages` hibaüzenet **szó szerinti bemásolása** —
+ * a legtermészetesebb fejlesztői reflex — a szabályt nem hozta be. Az első hipotézisem (rangsor-hiba) a
+ * mérésen **MEGBUKOTT**: a 60 visszaadott találatból **egy sem tartalmazta a „402"-t**, vagyis a mondatot
+ * hordozó chunk **be sem került a jelöltek közé**. Ez **recall-hiba**: egy kontextus nélküli hibaüzenet
+ * embeddingje távol esik a szabály-próza embeddingjétől, és amit a vektor-réteg nem hoz be, azt semmilyen
+ * rangsor-javítás nem érheti el.
+ *
+ * **A megoldás mintája MÁR LÉTEZIK:** a FEAT-003 kód-expanzió (`applyCodeExpansion`) pontosan ezt csinálja
+ * azonosító-kódokra — ha a query kódot tartalmaz, a citáló elemek determinisztikusan bekerülnek, a
+ * vektor-rangsortól függetlenül. Ez a util ugyanezt terjeszti ki a **szó szerinti idézetre**.
+ *
+ * **Miért kell szigorú kapu.** A mentés Mongo-oldali szöveg-keresés, ami a nagy tárakon collection-scan.
+ * Mérve (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. Ezért a mentés (1) csak IDÉZET-SZERŰ query-re fut, és (2) csak
+ * a `read.literalRescueMaxDocs` alatti méretű tárakon.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FAM_LiteralPhrase_Util = void 0;
+/** A minimális token-szám: ennél rövidebb részlet nem idézet, hanem véletlen szó-egybeesés. */
+const MIN_TOKENS = 5;
+/** A maximális token-szám: a hosszú promptot levágjuk (a regex-költség és a találhatóság miatt is). */
+const MAX_TOKENS = 16;
+/**
+ * A „disztinktív" token minimális hossza. Egy csupa rövid, köznapi szóból álló mondat (`mi a teendo ha a
+ * build elszall`) nem idézet — az a normál szemantikus keresés dolga. Számjegyet tartalmazó token (hibakód,
+ * verzió, azonosító) MINDIG disztinktívnek számít.
+ */
+const DISTINCTIVE_LEN = 7;
+class FAM_LiteralPhrase_Util {
+    /**
+     * IDÉZET-SZERŰ-e a query, és ha igen, mit keressünk. `undefined` = nem éri meg a szöveg-keresés.
+     *
+     * **Ismert korlát, nyíltan:** a keresett szöveg a query ELEJÉTŐL vett, `MAX_TOKENS`-ig tartó összefüggő
+     * részlet — vagyis a TISZTÁN bemásolt idézetre működik. Ha a felhasználó saját mondatba ágyazza az
+     * idézetet („npm publish failed with 402 … what should I do"), a szó szerinti egyezés elmarad, és a
+     * mentés nem talál. Az a hibaosztály viszont **mérve nem is szorul mentésre**: ott a normál vektor-út
+     * behozza a szabályt (#2 helyezés). A mentés a lyukat foltozza, nem a működő utat írja át.
+     */
+    static extract(query) {
+        const tokens = String(query ?? '')
+            .toLowerCase()
+            .split(/[^a-z0-9áéíóöőúüű]+/)
+            .filter((token) => token.length >= 2);
+        if (tokens.length < MIN_TOKENS) {
+            return undefined;
+        }
+        const window = tokens.slice(0, MAX_TOKENS);
+        if (!window.some((token) => FAM_LiteralPhrase_Util.isDistinctive(token))) {
+            return undefined;
+        }
+        return { phrase: window.join(' '), tokenCount: window.length };
+    }
+    /** Disztinktív-e a token: számjegyet tartalmaz (hibakód/verzió/azonosító) VAGY elég hosszú. */
+    static isDistinctive(token) {
+        return /[0-9]/.test(token) || token.length >= DISTINCTIVE_LEN;
+    }
+    /**
+     * A szó szerinti kereséshez használt regex: a tokenek között TETSZŐLEGES nem-alfanumerikus elválasztó
+     * állhat, mert a korpuszban a mondat írásjelekkel, sortöréssel, backtickkel tagolt (`402 Payment
+     * Required — You must…`). A tokenek escape-elve — a query SOHA nem tud regexet injektálni.
+     */
+    static toRegexSource(phrase) {
+        return phrase
+            .split(' ')
+            .map((token) => token.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'))
+            .join('[^a-z0-9áéíóöőúüű]+');
+    }
+}
+exports.FAM_LiteralPhrase_Util = FAM_LiteralPhrase_Util;

package/build/src/_modules/retrieval/_collections/fam-memory-retention.util.js

@@ -0,0 +1,70 @@
+"use strict";
+/**
+ * MEMÓRIA-RETENCIÓ — az alvó beszélgetés-törmelék nyugdíjazásának döntési logikája (2026-09-02).
+ *
+ * **A probléma (mérve).** Az aktív `memory` tár 20,2%-a (8 717 bejegyzés) nyers user-prompt
+ * (`kind: user_prompt` / `tags: [temporary_context]`) — egy egyszeri, 2026-06-os claude-mem import
+ * hagyatéka (azóta 4 új keletkezett, tehát NINCS élő csap). **98,2%-uk soha nem lett felidézve**, mégis
+ * teljes súllyal versenyeznek a gondozott jegyzetekkel a nyers koszinusz-rangsorban — és mivel rövidek
+ * és tematikusak, gyakran nyernek is.
+ *
+ * **A szabály (v2, owner: „javítsd, amit kell" — 2026-09-02):** a törmelék-osztály 30+ nap után nyugdíjba
+ * vonul, a felidézés-számtól FÜGGETLENÜL.
+ *
+ * **Miért nem véd a `recallCount` ezen az osztályon — mérve.** Az első változat a „amit többet használtunk,
+ * az tovább él" elv szerint kivételezett a valaha felidézettekkel (164 túlélő). Az audit ezt megbuktatta:
+ * a legtöbbet „felidézett" túlélők **gépi zaj** voltak — `<task-notification>` és `<ide_opened_file>`
+ * XML-blokkok, recall=281-gyel a csúcson (67/164 tisztán ilyen; a maradék átirat-üledék: „Látod", „Azt",
+ * build-logok). A felidézés AUTOMATIKUS (minden visszaadott találat recallCount++-t kap), így ezen az
+ * osztályon a szám a RANGSOR-KITETTSÉGET méri, nem a használatot — és öngerjesztő: ami magasra rangsorol,
+ * azt a visszaadás „felidézi", amitől védetté válik. Az owner elve a MEMÓRIÁKRA vonatkozik; a nyers
+ * átirat-törmelék nem az. A nyugdíj ettől még NEM törlés: minden hidegen kereshető marad, és
+ * visszafordítható — a genuinly hasznos darab a cold-search-ben él, vagy gondozott bejegyzésként újraírható.
+ *
+ * Ugyanezen mérés miatt a REAKTIVÁCIÓ is kihagyja ezt az osztályt (`selectMemoryIds` szűrője) — a hurok
+ * motorja leállt: a törmelék többé nem tud „használtnak" látszani attól, hogy előkerül.
+ *
+ * **A nyugdíj NEM törlés:** `superseded: true` + `retiredAt` — a tartalom és a vektor a poolban marad,
+ * a `memory.supersededPenalty` (0.25) süllyeszti, a cold-search megtalálja. Visszafordítható.
+ *
+ * **Hatókör-korlátok (mind mért indokkal):**
+ *  - CSAK a törmelék-osztály (`user_prompt` / `temporary_context`) — a `session-observation` NEM az:
+ *    24%-a felidézett és ma is aktívan nő; a `memory_entry` a gondozott törzs.
+ *  - CSAK a 30+ naposak (`memory.retireTemporaryAfterDays`) — a friss kontextus a session alatt még
+ *    ténylegesen kontextus; utána üledék.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FAM_MemoryRetention_Util = void 0;
+/** A törmelék-osztály definíciója — UGYANAZ, amit a kereszt-tár szonda kizár (egy definíció, két felhasználás). */
+const DEBRIS_KINDS = ['user_prompt'];
+const DEBRIS_TAGS = ['temporary_context'];
+const DAY_MS = 24 * 60 * 60 * 1000;
+class FAM_MemoryRetention_Util {
+    /** Törmelék-osztályú-e a bejegyzés (nyers prompt / átmeneti kontextus). */
+    static isDebris(candidate) {
+        if (candidate.kind && DEBRIS_KINDS.includes(candidate.kind)) {
+            return true;
+        }
+        return (candidate.tags ?? []).some((tag) => DEBRIS_TAGS.includes(tag));
+    }
+    /**
+     * A döntés egyetlen bejegyzésre. A sorrend a VÉDELMI sorrend: előbb a kizáró okok (nem törmelék /
+     * már nyugdíjas / túl friss), és csak ha egyik sem áll, akkor `retire`. A `recallCount` ITT SZÁNDÉKOSAN
+     * nem véd — az indoklás (mért öngerjesztő hurok) a fájl fejlécében.
+     */
+    static decide(candidate, set) {
+        if (!FAM_MemoryRetention_Util.isDebris(candidate)) {
+            return 'keep-not-debris';
+        }
+        if (candidate.superseded === true) {
+            return 'keep-already-superseded';
+        }
+        const createdAt = typeof candidate.createdAt === 'number' ? candidate.createdAt : Number.NaN;
+        // Datum nelkuli bejegyzest NEM nyugdijazunk — a hianyzo teny nem bizonyitek az oregsegre.
+        if (!Number.isFinite(createdAt) || set.now - createdAt < set.retireAfterDays * DAY_MS) {
+            return 'keep-too-young';
+        }
+        return 'retire';
+    }
+}
+exports.FAM_MemoryRetention_Util = FAM_MemoryRetention_Util;

package/build/src/_modules/retrieval/_services/fam-memory-reactivation.control-service.js

@@ -7,6 +7,7 @@ const fsm_dynamo_1 = require("@futdevpro/fsm-dynamo");
 const fam_table_type_enum_1 = require("../../../_enums/fam-table.type-enum");
 const embedding_1 = require("../../embedding");
 const fam_memory_data_model_1 = require("../../../_models/data-models/fam-memory.data-model");
+const fam_memory_retention_util_1 = require("../_collections/fam-memory-retention.util");
 /**
  * `FAM_MemoryReactivation_ControlService` (dsgn-013 §4, MAM F2) — a memória FELIDÉZÉS-megerősítése. Amikor a `read`
  * ténylegesen VISSZAAD egy `memory`-hitet (a felhasználó/agent felidézte), az „új energiát kap": `lastRecalledAt = now`,
@@ -55,7 +56,13 @@ class FAM_MemoryReactivation_ControlService {
      */
     static selectMemoryIds(hits) {
         const ids = hits
-            .filter((hit) => hit.table === fam_table_type_enum_1.FAM_Table.memory && typeof hit.id === 'string' && hit.id.length > 0)
+            .filter((hit) => hit.table === fam_table_type_enum_1.FAM_Table.memory && typeof hit.id === 'string' && hit.id.length > 0
+            // A TORMELEK-osztaly (user_prompt / temporary_context) NEM kap felidezes-megerositest
+            // (2026-09-02, mert ongerjeszto hurok): a rovid atirat-toredek magasra rangsorol -> a
+            // visszaadas automatikus recallCount++-t adott -> "hasznaltnak" latszott es a retencio
+            // vedte. A csucson recall=281 egy <task-notification> XML-blokkon. A szamlalo ezen az
+            // osztalyon a rangsor-kitettseget merte, nem a hasznalatot — a motor itt all le.
+            && !fam_memory_retention_util_1.FAM_MemoryRetention_Util.isDebris({ kind: hit.kind, tags: hit.tags }))
             .map((hit) => hit.id);
         return Array.from(new Set(ids));
     }

package/build/src/_modules/retrieval/_services/fam-memory-retention.control-service.js

@@ -0,0 +1,118 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FAM_MemoryRetention_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_table_type_enum_1 = require("../../../_enums/fam-table.type-enum");
+const embedding_1 = require("../../embedding");
+const config_control_service_1 = require("../../../_routes/server/config/config.control-service");
+const fam_memory_retention_util_1 = require("../_collections/fam-memory-retention.util");
+/**
+ * MEMÓRIA-RETENCIÓ (2026-09-02) — az alvó beszélgetés-törmelék heti nyugdíjazása. A döntési logika és a
+ * teljes indoklás a pure utilban (`fam-memory-retention.util.ts`); ez a réteg a Mongo-munka.
+ *
+ * A nyugdíj = `superseded: true` + `retiredAt` — NEM törlés: a tartalom és a vektor a poolban marad
+ * (a `memory.supersededPenalty` süllyeszti, a cold-search megtalálja). A pool-hoz ezért NEM nyúlunk
+ * (nincs `removeVector`) — pontosan úgy, ahogy a tartalom-leváltásos `superseded` ág sem teszi.
+ *
+ * **Heti automatika:** a scan-scheduler a heti re-scan UTÁN hívja (`memory.retireTemporaryEnabled`,
+ * default true) — a retenció lényege az automatizmus, különben a törmelék sosem vonul nyugdíjba.
+ */
+class FAM_MemoryRetention_ControlService {
+    static _instance;
+    static getInstance() {
+        if (!FAM_MemoryRetention_ControlService._instance) {
+            FAM_MemoryRetention_ControlService._instance = new FAM_MemoryRetention_ControlService();
+        }
+        return FAM_MemoryRetention_ControlService._instance;
+    }
+    /** A retenció futtatása — `dryRun` esetén CSAK mér, semmit nem ír. */
+    async retire(input = {}) {
+        const dryRun = input.dryRun !== false;
+        const retireAfterDays = typeof input.retireAfterDays === 'number' && input.retireAfterDays > 0
+            ? Math.floor(input.retireAfterDays)
+            : await this.resolveRetireAfterDays();
+        const registryEntry = embedding_1.FAM_StoreRegistry_Util.getEntry(fam_table_type_enum_1.FAM_Table.memory);
+        if (!registryEntry) {
+            throw new Error('A memory tár nincs a store-registry-ben — a retenció nem futtatható.');
+        }
+        // A példányosítás regisztrálja a mongoose-modellt (a raw collection eléréséhez) — a bevett minta.
+        new embedding_1.FAM_Entry_DataService({ dataParams: registryEntry.dataParams, issuer: 'memory-retention' });
+        const collection = mongoose_1.default.models[registryEntry.dataParams.dataName]?.collection;
+        if (!collection) {
+            throw new Error('A memory collection nem elérhető — a retenció nem futtatható.');
+        }
+        // CSAK a törmelék-osztály kerül a jelölt-halmazba (a Mongo szűr, nem mi töltünk fölöslegesen) —
+        // a szűkítés a pure util definícióját tükrözi; a végső döntést bejegyzésenként a util hozza.
+        const raw = await collection.find({
+            _deleted: null,
+            $or: [{ kind: 'user_prompt' }, { tags: 'temporary_context' }],
+        }, { projection: { kind: 1, tags: 1, recallCount: 1, superseded: 1, __created: 1 } }).toArray();
+        const now = Date.now();
+        const toRetire = [];
+        let keptTooYoung = 0;
+        let alreadySuperseded = 0;
+        for (const row of raw) {
+            const candidate = {
+                id: String(row._id),
+                kind: row.kind,
+                tags: row.tags,
+                recallCount: row.recallCount,
+                superseded: row.superseded,
+                createdAt: row.__created instanceof Date ? row.__created.getTime() : undefined,
+            };
+            const verdict = fam_memory_retention_util_1.FAM_MemoryRetention_Util.decide(candidate, { now: now, retireAfterDays: retireAfterDays });
+            if (verdict === 'retire') {
+                toRetire.push(row._id);
+            }
+            else if (verdict === 'keep-too-young') {
+                keptTooYoung++;
+            }
+            else if (verdict === 'keep-already-superseded') {
+                alreadySuperseded++;
+            }
+            // `keep-not-debris` a Mongo-szűrő miatt nem fordulhat elő — ha mégis, az csendben kimarad
+            // a számlálókból, és a `scanned - összeg` eltérés jelzi a szűrő-drift-et.
+        }
+        if (!dryRun && toRetire.length) {
+            await collection.updateMany({ _id: { $in: toRetire } }, { $set: { superseded: true, retiredAt: now } });
+            fsm_dynamo_1.DyFM_Log.log(`[memory-retention] ${toRetire.length} alvo tormelek-bejegyzes nyugdijazva `
+                + `(superseded+retiredAt; ${keptTooYoung} meg fiatal — a recallCount ezen az osztalyon nem ved, `
+                + 'mert ongerjeszto rangsor-kitettseget mert).');
+        }
+        return {
+            operation: 'retire_temporary_memories',
+            dryRun: dryRun,
+            retireAfterDays: retireAfterDays,
+            scanned: raw.length,
+            retired: toRetire.length,
+            keptTooYoung: keptTooYoung,
+            alreadySuperseded: alreadySuperseded,
+        };
+    }
+    /** A `memory.retireTemporaryAfterDays` feloldása (hiba/hiány → 30 — a retenció sosem bukik configon). */
+    async resolveRetireAfterDays() {
+        try {
+            const value = (await config_control_service_1.FAM_Config_ControlService.getInstance()
+                .resolve('memory.retireTemporaryAfterDays', { table: fam_table_type_enum_1.FAM_Table.memory })).value;
+            const num = typeof value === 'number' ? value : Number(value);
+            return Number.isFinite(num) && num > 0 ? Math.floor(num) : 30;
+        }
+        catch {
+            return 30;
+        }
+    }
+    /** Engedélyezett-e a heti automatika (`memory.retireTemporaryEnabled`, default true). */
+    async isAutoEnabled() {
+        try {
+            const value = (await config_control_service_1.FAM_Config_ControlService.getInstance()
+                .resolve('memory.retireTemporaryEnabled', { table: fam_table_type_enum_1.FAM_Table.memory })).value;
+            return value !== false;
+        }
+        catch {
+            return true;
+        }
+    }
+}
+exports.FAM_MemoryRetention_ControlService = FAM_MemoryRetention_ControlService;

package/build/src/_modules/retrieval/_services/fam-retrieval-candidate.data-service.js

@@ -56,6 +56,39 @@ class FAM_RetrievalCandidate_DataService {
         filter.referenceCodes = { $in: codes };
         return this.findActiveCandidates(registryEntry, filter);
     }
+    /**
+     * SZÓ SZERINTI IDÉZET-MENTÉS (2026-09-02): a `phrase`-t szó szerint tartalmazó aktív entry-k.
+     *
+     * **Miért kell:** mérve, a bemásolt hibaüzenetet hordozó chunk BE SEM KERÜL a vektor-jelöltek közé
+     * (60 találatból 0 tartalmazta a keresett stringet) — ez recall-hiba, amit rangsorolással nem lehet
+     * javítani. A minta a FEAT-003 kód-expanzió: determinisztikus, pontos egyezés a vektor-úton KÍVÜL.
+     *
+     * **MÉRET-KAPU (kötelező):** a `content` substring-keresés NEM indexelhető → collection-scan. Mérve:
+     * `rules` 296 ms · `coding_patterns` 504 ms · `knowledge` 2,1 s · `memory` 4,9 s · `documents` 13,1 s ·
+     * `codebase` 45,2 s. A `maxDocs` fölötti tár **kihagyva** (üres lista) — a mentés SOHA nem tehet egy
+     * olvasást másodperces műveletté. A darabszám `estimatedDocumentCount` (collection-metaadat, ~0 ms).
+     */
+    async loadByLiteralPhrase(input, regexSource, set) {
+        const registryEntry = embedding_1.FAM_StoreRegistry_Util.getEntry(input.table);
+        if (!registryEntry || !regexSource) {
+            return [];
+        }
+        const model = mongoose_1.default.models[registryEntry.dataParams.dataName];
+        if (!model) {
+            return [];
+        }
+        const size = await model.collection.estimatedDocumentCount();
+        if (size > set.maxDocs) {
+            return [];
+        }
+        const filter = this.buildFilter(input, registryEntry);
+        filter.content = { $regex: regexSource, $options: 'i' };
+        const rows = await model.collection
+            .find({ ...filter, _deleted: null }, { projection: { contentVector: 0 } })
+            .limit(set.limit)
+            .toArray();
+        return rows;
+    }
     /**
      * A topK-hit metaadat-betöltése `_id`-listából (az UNSCOPED read-fast-path-hez, SP-5.x perf). A főpool-
      * keresés UTÁN CSAK a tényleges hit-eket tölti (a hit-row + weight + recency összefűzéséhez), NEM mind a

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

@@ -12,6 +12,7 @@ const fam_retrieval_candidate_data_service_1 = require("./fam-retrieval-candidat
 const fam_retrieval_suggestions_util_1 = require("./fam-retrieval-suggestions.util");
 const fam_memory_activation_util_1 = require("../_collections/fam-memory-activation.util");
 const fam_lexical_match_util_1 = require("../_collections/fam-lexical-match.util");
+const fam_literal_phrase_util_1 = require("../_collections/fam-literal-phrase.util");
 const fam_result_diversity_util_1 = require("../_collections/fam-result-diversity.util");
 const fam_memory_reactivation_control_service_1 = require("./fam-memory-reactivation.control-service");
 const fam_memory_cold_search_control_service_1 = require("./fam-memory-cold-search.control-service");
@@ -100,7 +101,12 @@ class FAM_Retrieval_ControlService {
         // FEAT-006 context-injection deduper: a hívó által MÁR injektált `_id`-k kizárása (a minScore/topK ELŐTT,
         // hogy ne foglaljanak helyet) — egy session ne kapja vissza ugyanazt a kontextust kétszer. A kizárás a
         // kód-exact-re IS vonatkozik (ha a session már birtokolja, nem kell újra, F3-1 ellenére sem).
-        const visibleHits = this.excludeSeen(mergedHits, query.excludeIds);
+        // ④c SZÓ SZERINTI IDÉZET-MENTÉS (2026-09-02): ha a query idézet-szerű, a pontosan egyező entry-k a
+        // vektor-úton KÍVÜL is bekerülnek. Mérve: a bemásolt hibaüzenet chunkja BE SEM KERÜLT a jelöltek
+        // közé (60/0), tehát ez recall-hiba — rangsorolással nem javítható. Ugyanaz a minta, mint a
+        // FEAT-003 kód-expanzió; a már bent lévő hitek NEM változnak, csak a hiányzók egészülnek ki.
+        const rescuedHits = await this.applyLiteralRescue({ query, config, scopeExpand, hits: mergedHits, includeContent });
+        const visibleHits = this.excludeSeen(rescuedHits, query.excludeIds);
         // ⑤ weight-szorzó MÁR a hit-eken (finalScore). ⑥ minScore-küszöb → relevantSet — DE F3-2: a kód-exact
         // citáció (`matchedCodes` nem-üres) BYPASS-olja a minScore-t (a determinisztikusan citált kód eleme
         // releváns a score-tól függetlenül; a `weight≤0` továbbra is kizárt, mert az már a merge ELŐTT kiesik).
@@ -125,7 +131,9 @@ class FAM_Retrieval_ControlService {
         }
         // dsgn-013 §4 (MAM F2) — FELIDÉZÉS-megerősítés: a ténylegesen VISSZAADOTT `memory`-hitek „új energiát kapnak"
         // (lastRecalledAt=now, recallCount++, dormant=false). ASYNC fire-and-forget — NEM blokkolja a read választ.
-        this.reactivateReturnedMemoryHits(result.hits, config);
+        if (!query.skipReactivation) {
+            this.reactivateReturnedMemoryHits(result.hits, config);
+        }
         return result;
     }
     /**
@@ -146,7 +154,7 @@ class FAM_Retrieval_ControlService {
             return undefined;
         }
         const asked = new Set(set.query.tables);
-        const probeTables = [fam_table_type_enum_1.FAM_Table.memory, fam_table_type_enum_1.FAM_Table.knowledge]
+        const probeTables = set.config.crossTableNoteProbeTables
             .filter((table) => !asked.has(table));
         if (!probeTables.length) {
             return undefined;
@@ -188,10 +196,18 @@ class FAM_Retrieval_ControlService {
     async probeTable(table, set) {
         const tableConfig = await this.resolveReadConfig(table, set.query);
         // A szonda SAJÁT, kicsi topK-val fut — nem második találati listát épít, csak eldönti, van-e erősebb.
-        const probeConfig = { ...tableConfig, topK: set.config.crossTableNoteTopK, minScore: 0 };
+        // A cold-search a KÖZVETLEN memória-kérdések dormant-mentőöve; egy mellék-jegyzet szondájának a
+        // forró pool elég — a superseded/dormant jelöltet úgyis kizárnánk. A szonda 3-as topK-jánál a
+        // `strongHotHits < topK` kapu szinte mindig nyitna, és a dormant-Mongo-munka a +514 ms része volt.
+        const probeConfig = {
+            ...tableConfig, topK: set.config.crossTableNoteTopK, minScore: 0,
+            memoryColdSearchEnabled: false,
+        };
         const hits = await this.searchTable({
             table: table, query: set.query, queryVector: set.queryVector,
             scopeExpand: set.scopeExpand, config: probeConfig, includeContent: false,
+            // 4× fejtér a superseded/törmelék/`weight<=0` szűrésnek — 500 helyett 12 betöltött entry.
+            vectorTopK: Math.max(12, set.config.crossTableNoteTopK * 4),
         });
         return hits.slice(0, set.config.crossTableNoteTopK).map((hit) => {
             // A `kind`/`tags`/`scope` NEM dekoráció: az MCP-n ÍRT memória-bejegyzésnek nincs fájl-útja
@@ -278,6 +294,57 @@ class FAM_Retrieval_ControlService {
         }
         return Array.from(byId.values());
     }
+    /**
+     * SZÓ SZERINTI IDÉZET-MENTÉS. A `FAM_LiteralPhrase_Util` dönti el, hogy a query idézet-szerű-e (a
+     * kritériumok és a mért indoklás ott); ha igen, a pontosan egyező entry-ket a data-service hozza be a
+     * MÉRET-KAPU betartásával. A már meglévő hitek ÉRINTETLENEK — a mentés csak kiegészít.
+     *
+     * A mentett entry `score`-ja NEM 1,0 (az a kód-expanzió exact-citation szintje): egy szó szerinti
+     * mondat-egyezés erős, de nem azonos egy explicit azonosító-citációval. A `LITERAL_RESCUE_SCORE` a
+     * `relevanceFloor` fölé teszi őket, a rangsorban pedig a szokásos szorzók (weight, lexikai boost —
+     * beleértve az idézet-bónuszt) döntenek. Így a mentés **felszínre hoz**, de nem **tol félre**.
+     *
+     * Hibatűrő: a mentés MELLÉK-szolgáltatás — ha elszáll, a válasz a vektor-találatokkal teljes.
+     */
+    async applyLiteralRescue(set) {
+        if (!set.config.literalRescueEnabled) {
+            return set.hits;
+        }
+        const literal = fam_literal_phrase_util_1.FAM_LiteralPhrase_Util.extract(set.query.query);
+        if (!literal) {
+            return set.hits;
+        }
+        try {
+            const byId = new Map();
+            for (const hit of set.hits) {
+                byId.set(hit.id, hit);
+            }
+            const regexSource = fam_literal_phrase_util_1.FAM_LiteralPhrase_Util.toRegexSource(literal.phrase);
+            for (const table of Array.from(new Set(set.query.tables))) {
+                const entries = await new fam_retrieval_candidate_data_service_1.FAM_RetrievalCandidate_DataService().loadByLiteralPhrase({
+                    table: table,
+                    scopeIdSet: set.scopeExpand.scopeIdSet,
+                    tagFilter: set.query.tagFilter,
+                    kindFilter: set.query.kindFilter,
+                }, regexSource, { maxDocs: set.config.literalRescueMaxDocs, limit: set.config.literalRescueLimit });
+                for (const entry of entries) {
+                    const id = entry._id ? String(entry._id) : undefined;
+                    const weight = entry.weight ?? 1;
+                    // A `weight<=0` kizárás KONZISZTENS a vektor-ággal — a mentés nem kerülheti meg a tiltást.
+                    if (!id || weight <= 0 || byId.has(id)) {
+                        continue;
+                    }
+                    byId.set(id, this.toLiteralRescueHit({ entry, id, table, weight, includeContent: set.includeContent }));
+                }
+            }
+            return Array.from(byId.values());
+        }
+        catch (error) {
+            fsm_dynamo_1.DyFM_Log.warn(`[read] a szo szerinti idezet-mentes hibara futott, a valasz a vektor-talalatokkal `
+                + `teljes: ${String(error)}`);
+            return set.hits;
+        }
+    }
     /**
      * Egy kód-citáló entry beolvasztása a hit-halmazba (FEAT-003). `score=1.0` (exact citation = maximális
      * relevancia), `finalScore=1.0×weight` (a meglévő weight-modellbe illesztve). `weight≤0` → kizárt
@@ -310,6 +377,37 @@ class FAM_Retrieval_ControlService {
         set.byId.set(id, this.toCodeHit({ entry: set.entry, id, table: set.table, weight, matched, includeContent: set.includeContent }));
     }
     /** Egy kód-citáló entry → `FAM_RetrievalHit` (exact citation: `score=1.0`, `matchedCodes` kitöltve). */
+    /**
+     * A mentett entry `score`-ja. SZÁNDÉKOSAN a `relevanceFloor` (0,60) FÖLÖTT, de a kód-expanzió
+     * exact-citation 1,0-ja ALATT: a szó szerinti mondat-egyezés erős jel, de nem azonos egy explicit
+     * azonosító-citációval. Így a mentett elem biztosan látszik, de nem söpri le a valódi top-találatokat.
+     */
+    static LITERAL_RESCUE_SCORE = 0.75;
+    /** Egy szó szerint egyező entry → `FAM_RetrievalHit` (idézet-mentés; a `matchedCodes` üres marad). */
+    toLiteralRescueHit(set) {
+        const lastModified = set.entry.__lastModified;
+        const score = FAM_Retrieval_ControlService.LITERAL_RESCUE_SCORE;
+        return {
+            id: set.id,
+            table: set.table,
+            score: score,
+            weight: set.weight,
+            finalScore: score * set.weight,
+            content: set.includeContent ? set.entry.content : undefined,
+            contentHash: set.entry.contentHash,
+            kind: set.entry.kind,
+            tags: set.entry.tags ?? [],
+            ...this.ruleMeta(set.entry, set.table),
+            scopePath: (set.entry.scopePath ?? []),
+            source: set.entry.source,
+            sourceFilePath: set.entry.sourceFilePath ?? null,
+            absolutePath: set.entry.source?.absolutePath ?? null,
+            chunkType: set.entry.chunkType,
+            headingPath: set.entry.headingPath ?? [],
+            position: set.entry.position,
+            lastModifiedMs: lastModified ? new Date(lastModified).getTime() : 0,
+        };
+    }
     toCodeHit(set) {
         const lastModified = set.entry.__lastModified;
         return {
@@ -365,7 +463,7 @@ class FAM_Retrieval_ControlService {
             vectorHits = await embedding_1.FAM_VectorSearch_ControlService.getInstance().search({
                 table: set.table,
                 queryVector: set.queryVector,
-                topK: exports.MAX_PAGE_SIZE,
+                topK: set.vectorTopK ?? exports.MAX_PAGE_SIZE,
             });
             if (!vectorHits.length) {
                 return [];
@@ -401,12 +499,15 @@ class FAM_Retrieval_ControlService {
                 table: set.table,
                 queryVector: set.queryVector,
                 candidateIds: candidateIds,
-                topK: Math.min(candidateIds.length, exports.MAX_PAGE_SIZE),
+                topK: Math.min(candidateIds.length, set.vectorTopK ?? exports.MAX_PAGE_SIZE),
             });
         }
         // ⑤ weight-szorzó: finalScore = score × (weight ?? 1); weight ≤ 0 → kizárt (nem kerül a hits közé).
         // Improvement 2: a query lexikai term-jeit EGYSZER tokenizáljuk (a hibrid keyword-boost-hoz a toHit-ban).
         const queryTerms = fam_lexical_match_util_1.FAM_LexicalMatch_Util.tokenize(set.query.query);
+        // A szó szerinti idézet-egyezéshez a NYERS, sorrendhelyes token-sorozat kell (stopwordökkel együtt) —
+        // EGYSZER számoljuk ki a query-re, nem hit-enként.
+        const queryPhraseTokens = fam_lexical_match_util_1.FAM_LexicalMatch_Util.tokenizeSequence(set.query.query);
         const hits = [];
         for (const vectorHit of vectorHits) {
             const entry = byId.get(vectorHit.id);
@@ -419,6 +520,7 @@ class FAM_Retrieval_ControlService {
             }
             hits.push(this.toHit({
                 entry, vectorHit, table: set.table, weight, queryTerms: queryTerms,
+                queryPhraseTokens: queryPhraseTokens,
                 importChunkWeight: set.config.importChunkWeight, importSourceWeight: set.config.importSourceWeight,
                 includeContent: set.includeContent, config: set.config, nowMs: Date.now(),
             }));
@@ -452,6 +554,7 @@ class FAM_Retrieval_ControlService {
         });
         const seen = new Set(hits.map((hit) => hit.id));
         const queryTerms = fam_lexical_match_util_1.FAM_LexicalMatch_Util.tokenize(query.query);
+        const queryPhraseTokens = fam_lexical_match_util_1.FAM_LexicalMatch_Util.tokenizeSequence(query.query);
         for (const cold of coldHits) {
             const id = cold.entry._id;
             const weight = cold.entry.weight ?? 1;
@@ -460,6 +563,7 @@ class FAM_Retrieval_ControlService {
             }
             hits.push(this.toHit({
                 entry: cold.entry, vectorHit: { id: id, score: cold.score }, table: set.table, weight: weight, queryTerms: queryTerms,
+                queryPhraseTokens: queryPhraseTokens,
                 importChunkWeight: set.config.importChunkWeight, importSourceWeight: set.config.importSourceWeight,
                 includeContent: set.includeContent, config: set.config, nowMs: Date.now(),
             }));
@@ -555,7 +659,7 @@ class FAM_Retrieval_ControlService {
         const lexicalScore = set.config.keywordWeight > 0
             ? fam_lexical_match_util_1.FAM_LexicalMatch_Util.score(set.queryTerms, {
                 content: set.entry.content, headingPath: set.entry.headingPath, sourceFilePath: set.entry.source?.path,
-            })
+            }, set.queryPhraseTokens)
             : 0;
         const keywordBoost = 1 + set.config.keywordWeight * lexicalScore;
         // PROJEKT-SZINTU szorzo a `.famconfig.json`-bol — SZANDEKOSAN a temperalason KIVUL. A `weight` mezo az
@@ -817,11 +921,23 @@ class FAM_Retrieval_ControlService {
         const memoryMaxFrequencyBoost = await this.resolveNumber(config, 'memory.maxFrequencyBoost', ctx, 2.5);
         const memoryActivationWeight = await this.resolveNumber(config, 'memory.activationWeight', ctx, 0.35);
         // KERESZT-TÁR „mellesleg"-javaslat (2026-09-01) — a `hits`-hez SOHA nem nyúl, csak külön mezőt ad.
+        // SZO SZERINTI IDEZET-MENTES (2026-09-02) — recall-javitas, meret-kapuval.
+        const literalRescueValue = (await config.resolve('read.literalRescueEnabled', ctx)).value;
+        const literalRescueEnabled = literalRescueValue !== false;
+        const literalRescueMaxDocs = await this.resolveNumber(config, 'read.literalRescueMaxDocs', ctx, 10000);
+        const literalRescueLimit = await this.resolveNumber(config, 'read.literalRescueLimit', ctx, 10);
         const crossTableNoteValue = (await config.resolve('read.crossTableNoteEnabled', ctx)).value;
         const crossTableNoteEnabled = crossTableNoteValue !== false;
         const crossTableNoteMinDelta = await this.resolveNumber(config, 'read.crossTableNoteMinDelta', ctx, 0.025);
         const crossTableNoteMinScore = await this.resolveNumber(config, 'read.crossTableNoteMinScore', ctx, 0.45);
         const crossTableNoteTopK = await this.resolveNumber(config, 'read.crossTableNoteTopK', ctx, 3);
+        const probeTablesRaw = (await config.resolve('read.crossTableNoteProbeTables', ctx)).value;
+        // Csak az ERVENYES szonda-tarak mennek at (memory/knowledge) — elgepelt config nem tud mas tarat szondazni.
+        const crossTableNoteProbeTables = String(typeof probeTablesRaw === 'string' ? probeTablesRaw : 'memory')
+            .split(',')
+            .map((item) => item.trim())
+            .filter((item) => item === fam_table_type_enum_1.FAM_Table.memory || item === fam_table_type_enum_1.FAM_Table.knowledge)
+            .map((item) => item);
         const memoryReactivateValue = (await config.resolve('memory.reactivateOnRead', ctx)).value;
         const memoryReactivateOnRead = memoryReactivateValue !== false;
         const memoryColdSearchValue = (await config.resolve('memory.coldSearchEnabled', ctx)).value;
@@ -831,10 +947,14 @@ class FAM_Retrieval_ControlService {
         return {
             topK: Math.min(topKDefault, exports.MAX_PAGE_SIZE),
             minScore: minScore,
+            literalRescueEnabled: literalRescueEnabled,
+            literalRescueMaxDocs: literalRescueMaxDocs,
+            literalRescueLimit: literalRescueLimit,
             crossTableNoteEnabled: crossTableNoteEnabled,
             crossTableNoteMinDelta: crossTableNoteMinDelta,
             crossTableNoteMinScore: crossTableNoteMinScore,
             crossTableNoteTopK: crossTableNoteTopK,
+            crossTableNoteProbeTables: crossTableNoteProbeTables.length ? crossTableNoteProbeTables : [fam_table_type_enum_1.FAM_Table.memory],
             relevanceFloor: relevanceFloor,
             importChunkWeight: importChunkWeight,
             importSourceWeight: importSourceWeight,

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

@@ -10,11 +10,16 @@
  * opcionális relevance-filter = BACKLOG (NEM épül).
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.FAM_RetrievalSuggestions_Util = exports.FAM_RetrievalCandidate_DataService = exports.FAM_RuleScopeContext_Util = exports.FAM_RulePropagation_Util = exports.FAM_RuleInjection_Util = exports.FAM_RuleInjection_ControlService = exports.FAM_GlobalRule_ControlService = exports.MAX_PAGE_SIZE = exports.FAM_Retrieval_ControlService = void 0;
+exports.FAM_RetrievalSuggestions_Util = exports.FAM_RetrievalCandidate_DataService = exports.FAM_RuleScopeContext_Util = exports.FAM_RulePropagation_Util = exports.FAM_RuleInjection_Util = exports.FAM_RuleInjection_ControlService = exports.FAM_GlobalRule_ControlService = exports.FAM_MemoryRetention_Util = exports.FAM_MemoryRetention_ControlService = exports.MAX_PAGE_SIZE = exports.FAM_Retrieval_ControlService = void 0;
 // SP-5.1/5.2/5.3 — a read-pipeline orchestrátor
 var fam_retrieval_control_service_1 = require("./_services/fam-retrieval.control-service");
 Object.defineProperty(exports, "FAM_Retrieval_ControlService", { enumerable: true, get: function () { return fam_retrieval_control_service_1.FAM_Retrieval_ControlService; } });
 Object.defineProperty(exports, "MAX_PAGE_SIZE", { enumerable: true, get: function () { return fam_retrieval_control_service_1.MAX_PAGE_SIZE; } });
+// Memoria-retencio (2026-09-02): az alvo tormelek heti nyugdijazasa — a dontesi logika a pure utilban.
+var fam_memory_retention_control_service_1 = require("./_services/fam-memory-retention.control-service");
+Object.defineProperty(exports, "FAM_MemoryRetention_ControlService", { enumerable: true, get: function () { return fam_memory_retention_control_service_1.FAM_MemoryRetention_ControlService; } });
+var fam_memory_retention_util_1 = require("./_collections/fam-memory-retention.util");
+Object.defineProperty(exports, "FAM_MemoryRetention_Util", { enumerable: true, get: function () { return fam_memory_retention_util_1.FAM_MemoryRetention_Util; } });
 var fam_global_rule_control_service_1 = require("./_services/fam-global-rule.control-service");
 Object.defineProperty(exports, "FAM_GlobalRule_ControlService", { enumerable: true, get: function () { return fam_global_rule_control_service_1.FAM_GlobalRule_ControlService; } });
 // Rules-Management MP-2 — always-apply rule-injektálás (SessionStart inject + read-reflex) szerver-oldali assembly

package/build/src/_routes/server/api/api.controller.js

@@ -70,6 +70,7 @@ class Api_Controller extends nts_dynamo_1.DyNTS_Controller {
             this.ingestRunsEndpoint(),
             this.duplicatesEndpoint(),
             this.duplicatesPruneEndpoint(),
+            this.memoryRetireEndpoint(),
             this.configGetEndpoint(),
             this.configSetEndpoint(),
             this.scanStartEndpoint(),
@@ -522,22 +523,26 @@ class Api_Controller extends nts_dynamo_1.DyNTS_Controller {
                 continue;
             }
             const collection = this.entryCollection(registryEntry);
-            const count = await collection.countDocuments({});
-            // Embedding-státusz bontás Mongo-aggregációval ($group), NEM a doc-ok memóriába töltésével.
+            // FIX (2026-09-02, COLLSCAN → index): a korábbi `countDocuments({})` + `$group embeddingStatus`
+            // TELJES collection-átolvasás volt (350k+ doc a nagy tárakon) — meleg Mongo-cache mellett
+            // észrevétlen, kihűlt cache + telített lemez mellett viszont 20–50 s/tár, és a `/stats` a UI
+            // landing alatt PERCEKIG lógott (mérve: 120 s+ timeout). Most:
+            //  • darabszám: `estimatedDocumentCount` (collection-metaadat, ~0 ms — a stats-kártyának a
+            //    nagyságrend kell, nem a tranzakció-pontos szám),
+            //  • státusz-bontás: per-státusz `countDocuments({embeddingStatus})` — az indexből számol
+            //    (COUNT_SCAN), doc-olvasás nélkül,
+            //  • utolsó módosítás: a friss `__lastModified` index tetejéről egyetlen doc.
+            const count = await collection.estimatedDocumentCount();
             const byStatus = { pending: 0, completed: 0, error: 0 };
-            const grouped = await collection
-                .aggregate([{ $group: { _id: '$embeddingStatus', n: { $sum: 1 } } }])
-                .toArray();
-            for (const group of grouped) {
-                const status = group._id ?? 'pending';
-                if (status in byStatus) {
-                    byStatus[status] += group.n;
-                }
-                else {
-                    byStatus.pending += group.n;
-                }
-            }
-            // Utolsó módosítás: EGYETLEN doc (a legfrissebb), csak az időbélyeg-mezőre projektálva.
+            const [completed, error] = await Promise.all([
+                collection.countDocuments({ embeddingStatus: 'completed' }),
+                collection.countDocuments({ embeddingStatus: 'error' }),
+            ]);
+            byStatus.completed = completed;
+            byStatus.error = error;
+            // A `pending` a maradék (beleértve a státusz-mentes régi doc-okat) — így nem kell harmadik scan.
+            byStatus.pending = Math.max(0, count - completed - error);
+            // Utolsó módosítás: EGYETLEN doc a `__lastModified` index tetejéről (2026-09-02 óta indexelt).
             const newest = await collection
                 .find({}, { projection: { __lastModified: 1 } })
                 .sort({ __lastModified: -1 })
@@ -658,6 +663,32 @@ class Api_Controller extends nts_dynamo_1.DyNTS_Controller {
         });
     }
     // =========================================================================
+    // /memory/retire-temporary — az alvó törmelék nyugdíjazása (dry-run az alapértelmezés)
+    // =========================================================================
+    /**
+     * `POST /memory/retire-temporary` — az alvó beszélgetés-törmelék (`user_prompt` / `temporary_context`)
+     * nyugdíjazása a `memory` táron: `superseded + retiredAt`, NEM törlés. A szabály és az indoklás a
+     * `fam-memory-retention.util.ts`-ben. Body: `dryRun` (DEFAULT `true`), `retireAfterDays` (override).
+     */
+    memoryRetireEndpoint() {
+        return new nts_dynamo_1.DyNTS_Endpoint_Params({
+            name: 'memoryRetireTemporary',
+            type: fsm_dynamo_1.DyFM_HttpCallType.post,
+            endpoint: '/memory/retire-temporary',
+            tasks: [
+                async (req, res) => {
+                    await this.run(res, async () => {
+                        const body = req.body ?? {};
+                        return retrieval_1.FAM_MemoryRetention_ControlService.getInstance().retire({
+                            dryRun: body.dryRun !== false,
+                            retireAfterDays: typeof body.retireAfterDays === 'number' ? body.retireAfterDays : undefined,
+                        });
+                    });
+                },
+            ],
+        });
+    }
+    // =========================================================================
     // /config — scoped config olvasás/írás (dsgn-007; a UI settings + CLI config)
     // =========================================================================
     /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@futdevpro/fdp-agent-memory",
-  "version": "1.1.177",
+  "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": {