@futdevpro/fdp-agent-memory 1.1.112 → 1.1.115

package/build/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@futdevpro/fdp-agent-memory",
-    "version": "1.1.112",
+    "version": "1.1.115",
     "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/_collections/config-catalog.const.js

@@ -140,6 +140,18 @@ exports.CONFIG_CATALOG = {
             + 'A tiszta-szemantikus találat (lexical 0) SOHA nem süllyed (×1). READ-time (nincs re-embed). `0` = pure-vektor '
             + '(régi viselkedés). Default 0.6.',
     },
+    'read.scanSummaryWeight': {
+        type: 'number', default: 1.0, min: 0.0, max: 10.0, levels: ALL_LEVELS,
+        description: 'A `source.type:"scan-summary"` (auto-generált projekt-összefoglaló: `project-identity` + '
+            + '`fs-summary`) chunkok EFFEKTÍV statikus weight-SAPKÁJA read-időben (2026-07-26 dispatch-eval): e '
+            + 'generikus entry-k `weight:3` (project-identity) / `weight:2` (fs-summary) → `finalScore ~2.2` még '
+            + 'lexicalScore 0-0.2 mellett is elnyomta a szemantikailag+lexikailag relevánsabb doksikat. E cap a '
+            + 'scan-summary effektív weight-jét `min(weight, scanSummaryWeight)`-re szorítja (factor = cap/weight), '
+            + 'hogy a STATIKUS weight NE tudja legyőzni a relevanciát. `1.0` = tiszta relevancia-rangsor (nincs statikus '
+            + 'boost); az identity-jellegű query-ken a summary a MAGAS cosine-ja miatt így is felszínre kerül (nincs '
+            + 'regresszió). READ-time (nincs re-embed); a nyers cosine + a `weight` DTO-mező NEM változik, csak a ranking. '
+            + 'A stored weight ALÁ csökkenteni is lehet (<1) az agresszívabb leszorításhoz; ≥ stored weight = kikapcsolva.',
+    },
     'read.denseResultRatio': {
         type: 'number', default: 2.0, min: 1.0, max: 50.0, levels: ALL_LEVELS,
         description: 'Dense-jelzés ratio-kapuja: totalRelevant >= ratio*topK → denseResults (dsgn-005 §4.2).',
@@ -393,6 +405,38 @@ exports.CONFIG_CATALOG = {
             + '(pl. mindig ugyanazon a tartalmon összeomló) job nem indul újra a végtelenségig minden restartkor. `0` = '
             + 'soha ne resume-olj automatikusan.',
     },
+    // --- 4.5b. Weekly auto full re-scan + delete-sync (fogyasztó: FAM_ScanScheduler_ControlService) ---
+    'scan.weeklyRescanEnabled': {
+        type: 'boolean', default: true, levels: GLOBAL_ONLY,
+        description: 'Heti automatikus TELJES FAM re-scan + törlés-szinkron (reconcile/delta) be/ki (2026-07-26). A meglévő '
+            + 'reconcile-logika (a scan orphan-soft-delete-eli a lemezről eltűnt fájlok chunkjait) HETI ütemezéssel fut, hogy '
+            + 'a FAM-tartalom naprakész maradjon. A cél a `scan.weeklyRescanRoot` (ha üres → a LEGUTÓBBI durable scan-job '
+            + 'cél-specjeit re-scanneli). Best-effort, in-process (nincs külső cron). `false` → nincs heti auto-re-scan.',
+    },
+    'scan.weeklyRescanDayOfWeek': {
+        type: 'number', default: 1, min: 0, max: 6, integer: true, levels: GLOBAL_ONLY,
+        description: 'A heti re-scan napja (LOKÁLIS idő): `0`=vasárnap … `1`=hétfő (default) … `6`=szombat. A slot a '
+            + '`scan.weeklyRescanHour` órán. Ha a szerver a slot-időben nem futott (down), a következő indításkor BEPÓTOLJA '
+            + '(catch-up: a legutóbbi elmúlt slot óta nem futott → most fut).',
+    },
+    'scan.weeklyRescanHour': {
+        type: 'number', default: 7, min: 0, max: 23, integer: true, levels: GLOBAL_ONLY,
+        description: 'A heti re-scan órája (LOKÁLIS idő, 0-23; default `7` = 07:00). A `scan.weeklyRescanDayOfWeek` napján ez '
+            + 'az óra:00 a heti slot.',
+    },
+    'scan.weeklyRescanRoot': {
+        type: 'string', default: '', levels: GLOBAL_ONLY,
+        description: 'A heti re-scan gyökere (abszolút út). Ha megadva → e root alatt felderített projektek re-scanje '
+            + '(reconcile-lel). Ha ÜRES (default) → a LEGUTÓBBI durable scan-job cél-specjeit re-scanneli (zero-config '
+            + 'freshness). Ha egyik sincs (üres + nincs korábbi scan) → a heti futás SKIP + egyszeri warn (nincs találgatás).',
+    },
+    'scan.weeklyRescanLastRunAt': {
+        type: 'number', default: 0, min: 0, max: 9999999999999, integer: true, levels: GLOBAL_ONLY,
+        description: 'ÁLLAPOT/observability (NEM felhasználói hangoló): a legutóbbi heti re-scan TRIGGER epoch-ms-e. A '
+            + 'scheduler ezzel dönti el, hogy egy heti slot óta futott-e már (idempotencia + catch-up + restart-storm '
+            + 'elleni védelem). `0` = még sosem futott. A scheduler írja; kézzel ne állítsd (a `fam config get`-tel '
+            + 'olvasható, mikor futott utoljára).',
+    },
     // --- 4.6. Reference / scope (fogyasztó: dsgn-002) ---
     'reference.cacheTtlMs': {
         type: 'number', default: 60000, min: 0, max: 3600000, integer: true, levels: GLOBAL_ONLY,

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

@@ -7,6 +7,7 @@ const fam_hydration_coordinator_control_service_1 = require("./fam-hydration-coo
 const fam_vector_search_control_service_1 = require("./fam-vector-search.control-service");
 const fam_scope_maintenance_control_service_1 = require("../../scope-reference/_services/fam-scope-maintenance.control-service");
 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");
 /**
  * `FAM_EmbeddingBootstrap_ControlService` (SP-2.2/2.4) — az embedding + vektor-réteg **boot-hook**-ja.
@@ -97,6 +98,15 @@ class FAM_EmbeddingBootstrap_ControlService {
         catch (error) {
             fsm_dynamo_1.DyFM_Log.warn(`[FAM bootstrap] memory-dormancy sweep sikertelen: ${error?.message}`);
         }
+        // HETI AUTO RE-SCAN + DELETE-SYNC (dispatch „Problem 2", 2026-07-26): az in-process ütemező telepítése — a heti
+        // slotot (default hétfő 07:00) figyeli + boot-catch-up-ol. A reconcile-logika már létezik; ez csak az ütemezés.
+        // Best-effort (a telepítés hibája nem buktatja a bootot; a scheduler maga is best-effort végig).
+        try {
+            fam_scan_scheduler_control_service_1.FAM_ScanScheduler_ControlService.getInstance().install();
+        }
+        catch (error) {
+            fsm_dynamo_1.DyFM_Log.warn(`[FAM bootstrap] heti re-scan scheduler telepítése sikertelen: ${error?.message}`);
+        }
     }
 }
 exports.FAM_EmbeddingBootstrap_ControlService = FAM_EmbeddingBootstrap_ControlService;

package/build/src/_modules/ingest/_services/fam-scan-job.data-service.js

@@ -30,5 +30,21 @@ class FAM_ScanJob_DataService extends nts_dynamo_1.DyNTS_DataService {
     async findResumable() {
         return this.findDataList({ status: { $in: ['running', 'pending'] } }, true);
     }
+    /**
+     * A LEGUTÓBB indított durable scan-job feloldott cél-specjei (weekly re-scan auto-derive, 2026-07-26): a `startedAt`
+     * szerint csökkenő rendben az ELSŐ job, amelynek nem-üres `specs`-e van. Így a heti re-scan zero-config újra-futtatja
+     * PONTOSAN a legutóbb szkennelt cél-halmazt (per-projekt path/scope/table), amikor nincs explicit `scan.weeklyRescanRoot`.
+     * `undefined`, ha még sosem volt cél-speces scan.
+     */
+    async findLatestScannedTargets() {
+        const found = await this.searchData({ sortBy: [{ key: 'startedAt', order: -1 }], pageSize: 25 });
+        for (const job of found.results ?? []) {
+            const specs = job.specs;
+            if (specs && specs.length) {
+                return specs;
+            }
+        }
+        return undefined;
+    }
 }
 exports.FAM_ScanJob_DataService = FAM_ScanJob_DataService;

package/build/src/_modules/ingest/_services/fam-scan-scheduler.control-service.js

@@ -0,0 +1,159 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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 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");
+/**
+ * `FAM_ScanScheduler_ControlService` (2026-07-26, dispatch „Problem 2") — a HETI automatikus TELJES FAM re-scan +
+ * törlés-szinkron (reconcile/delta) IN-PROCESS ütemezője. A reconcile-logika MÁR LÉTEZIK (a scan orphan-soft-delete-eli
+ * a lemezről eltűnt fájlok chunkjait, dsgn `scan.reconcileIgnored`); ez a service CSAK az ÜTEMEZÉST adja hozzá, hogy a
+ * FAM-tartalom naprakész maradjon anélkül, hogy manuálisan re-scannelni kellene.
+ *
+ * **Slot:** LOKÁLIS idő `scan.weeklyRescanDayOfWeek` (default 1 = hétfő) @ `scan.weeklyRescanHour`:00 (default 7 → 07:00).
+ * **Catch-up:** egy fix időközű tick (10 perc) figyeli, hogy a LEGUTÓBBI elmúlt slot óta futott-e már (`scan.weeklyRescanLastRunAt`).
+ * Ha a szerver a slot-időben nem futott (down/restart), a következő indításkor BEPÓTOL — a heti freshness így restart-tűrő.
+ * **Restart-storm ellen:** a `lastRunAt` a config-store-ban perzisztál → egy héten belüli restart NEM indít újabb re-scant.
+ * **Cél:** `scan.weeklyRescanRoot` (ha megadva) VAGY a legutóbbi durable scan-job cél-specjei (zero-config). Egyik sincs → SKIP + warn.
+ * Best-effort végig (a hibák logolódnak, a szerver-start/futás NEM bukik el).
+ */
+class FAM_ScanScheduler_ControlService {
+    static _instance;
+    issuer = 'FAM_ScanScheduler_ControlService';
+    timer;
+    ticking = false;
+    /** A slot-ellenőrzés fix pollozási időköze (ms) — 10 perc. NEM a heti slot; csak „megnéztük-e már, hogy due-e". */
+    static CHECK_INTERVAL_MS = 600000;
+    static getInstance() {
+        if (!FAM_ScanScheduler_ControlService._instance) {
+            FAM_ScanScheduler_ControlService._instance = new FAM_ScanScheduler_ControlService();
+        }
+        return FAM_ScanScheduler_ControlService._instance;
+    }
+    /** Teszt-reset (a singleton + a timer ürítése). */
+    static resetForTest() {
+        FAM_ScanScheduler_ControlService._instance?.uninstall();
+        FAM_ScanScheduler_ControlService._instance = undefined;
+    }
+    /**
+     * A boot() best-effort hívja: beállít egy periodikus tick-et (CHECK_INTERVAL_MS), ami a heti slotot figyeli, majd
+     * AZONNAL futtat egy első tick-et (boot-catch-up: ha a legutóbbi slot már elmúlt és nem futott, most bepótol).
+     * Idempotens (kétszeri install → egy timer). A timer `unref`-elt (nem tartja életben a processt önmagában).
+     */
+    install() {
+        if (this.timer) {
+            return;
+        }
+        this.timer = setInterval(() => { void this.tick(Date.now()); }, FAM_ScanScheduler_ControlService.CHECK_INTERVAL_MS);
+        if (typeof this.timer.unref === 'function') {
+            this.timer.unref();
+        }
+        fsm_dynamo_1.DyFM_Log.info(`[FAM scanScheduler] heti re-scan figyelő telepítve (tick ${FAM_ScanScheduler_ControlService.CHECK_INTERVAL_MS / 60000} percenként).`);
+        void this.tick(Date.now());
+    }
+    /** A timer leállítása (teszt / graceful). */
+    uninstall() {
+        if (this.timer) {
+            clearInterval(this.timer);
+            this.timer = undefined;
+        }
+    }
+    /**
+     * Egy ellenőrzési ciklus: DUE-e a heti slot? Ha igen → rögzíti a `lastRunAt`-ot (idempotencia + restart-storm ellen),
+     * majd elindítja a re-scant. Best-effort (nem dob). Re-entráns-védett (`ticking`), hogy egy lassú tick ne fedjen át
+     * a következővel.
+     */
+    async tick(nowMs) {
+        if (this.ticking) {
+            return;
+        }
+        this.ticking = true;
+        try {
+            const config = config_control_service_1.FAM_Config_ControlService.getInstance();
+            const enabled = (await config.resolve('scan.weeklyRescanEnabled')).value;
+            if (enabled === false) {
+                return;
+            }
+            const day = await this.resolveNum(config, 'scan.weeklyRescanDayOfWeek', 1);
+            const hour = await this.resolveNum(config, 'scan.weeklyRescanHour', 7);
+            const lastRun = await this.resolveNum(config, 'scan.weeklyRescanLastRunAt', 0);
+            const slot = FAM_ScanScheduler_ControlService.mostRecentSlotAtOrBefore(nowMs, day, hour);
+            if (lastRun >= slot) {
+                return; // e heti slot óta már futott (vagy még nem jött el a slot)
+            }
+            // DUE: ELŐBB rögzítjük a lastRun-t (így egy crash mid-scan sem indít újra minden restartkor; a heti freshness
+            // best-effort, nem exactly-once), MAJD indítjuk a scant.
+            await this.markRan(config, nowMs);
+            await this.triggerRescan();
+        }
+        catch (error) {
+            fsm_dynamo_1.DyFM_Log.warn(`[FAM scanScheduler] heti re-scan tick sikertelen (best-effort): ${error?.message}`);
+        }
+        finally {
+            this.ticking = false;
+        }
+    }
+    /** 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' };
+        const config = config_control_service_1.FAM_Config_ControlService.getInstance();
+        const rootValue = (await config.resolve('scan.weeklyRescanRoot')).value;
+        const root = typeof rootValue === 'string' ? rootValue.trim() : '';
+        if (root) {
+            await fam_scan_job_control_service_1.FAM_ScanJob_ControlService.getInstance().start({ root: root, sourceLocation: root, origin: origin, waitMs: 0 });
+            fsm_dynamo_1.DyFM_Log.info(`[FAM scanScheduler] heti TELJES re-scan + reconcile INDÍTVA (root: ${root}).`);
+            return;
+        }
+        // Zero-config: a legutóbbi durable scan-job feloldott cél-specjei (ugyanaz a cél-halmaz, reconcile-lel).
+        const targets = await this.loadLatestScannedTargets();
+        if (targets && targets.length) {
+            await fam_scan_job_control_service_1.FAM_ScanJob_ControlService.getInstance().start({ projects: targets, origin: origin, waitMs: 0 });
+            fsm_dynamo_1.DyFM_Log.info(`[FAM scanScheduler] heti TELJES re-scan + reconcile INDÍTVA (${targets.length} cél a legutóbbi scan-ből).`);
+            return;
+        }
+        fsm_dynamo_1.DyFM_Log.warn('[FAM scanScheduler] heti re-scan esedékes, DE nincs cél: állítsd be a `scan.weeklyRescanRoot`-ot '
+            + 'vagy futtass egy scant előbb (durable cél-specek) — most SKIP.');
+    }
+    /**
+     * A legutóbbi durable scan-job feloldott cél-specjei (zero-config re-scan). KÜLÖN metódus, hogy a `DyNTS_DataService`
+     * eager DB-resolve-ja (memory: `dynts_dataservice_eager_resolve`) NE példányosítsa a data-service-t a DB-mentes unit
+     * tesztekben — a teszt ezt a metódust spy-olja. A tényleges query a `FAM_ScanJob_DataService` specjében fedve.
+     */
+    async loadLatestScannedTargets() {
+        return new fam_scan_job_data_service_1.FAM_ScanJob_DataService({ issuer: this.issuer }).findLatestScannedTargets();
+    }
+    /** A `lastRunAt` állapot perzisztálása a config-store-ba (global szint). Best-effort. */
+    async markRan(config, nowMs) {
+        try {
+            await config.set('scan.weeklyRescanLastRunAt', nowMs, {
+                level: fam_config_level_type_enum_1.FAM_ConfigLevel.global, setBy: 'system', note: 'weekly re-scan trigger',
+            });
+        }
+        catch (error) {
+            fsm_dynamo_1.DyFM_Log.warn(`[FAM scanScheduler] lastRunAt perzisztálás sikertelen: ${error?.message}`);
+        }
+    }
+    /** Egy szám-config feloldása a default-tal. */
+    async resolveNum(config, key, fallback) {
+        const value = (await config.resolve(key)).value;
+        return typeof value === 'number' ? value : fallback;
+    }
+    /**
+     * PURE, tesztelhető: a `nowMs`-nál NEM-későbbi legutóbbi (`dayOfWeek` @ `hour`:00) LOKÁLIS-idő slot epoch-ms-e.
+     * (a) ma `hour`:00-ra állítja, (b) visszalép a cél-hétköznapra (`getDay()` diff, 0=vasárnap), (c) ha az így kapott
+     * slot még a JÖVŐben van (ma a cél-nap, de a `hour` még nem jött el), egy héttel korábbra lép. DST-re best-effort.
+     */
+    static mostRecentSlotAtOrBefore(nowMs, dayOfWeek, hour) {
+        const d = new Date(nowMs);
+        d.setHours(hour, 0, 0, 0);
+        const dayDiff = (d.getDay() - dayOfWeek + 7) % 7;
+        d.setDate(d.getDate() - dayDiff);
+        if (d.getTime() > nowMs) {
+            d.setDate(d.getDate() - 7);
+        }
+        return d.getTime();
+    }
+}
+exports.FAM_ScanScheduler_ControlService = FAM_ScanScheduler_ControlService;

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

@@ -398,6 +398,22 @@ class FAM_Retrieval_ControlService {
     importSourceFactor(source, importSourceWeight) {
         return source?.type === 'import' ? importSourceWeight : 1;
     }
+    /**
+     * Scan-summary read-idejű weight-SAPKA (2026-07-26 dispatch-eval): az auto-generált projekt-összefoglaló
+     * (`source.type:'scan-summary'` — EGYSZERRE fedi a `project-identity` weight:3 ÉS az `fs-summary` weight:2
+     * entry-ket) statikus weight-boost-ját neutralizálja. Mérve: e generikus chunkok `finalScore ~1.3-2.2`-vel a
+     * TOP-hitek lettek OFF-topic query-ken is (lexicalScore 0-0.2), elnyomva a relevánsabb doksikat. A factor a
+     * effektív weight-et `min(weight, scanSummaryWeight)`-re szorítja (weight > cap → `cap/weight`, különben ×1),
+     * így a STATIKUS weight NEM tudja legyőzni a szemantikai + lexikai relevanciát. `scanSummaryWeight=1.0` (default)
+     * → tiszta relevancia-rangsor; az identity-query-ken a summary a MAGAS cosine miatt így is felszínre kerül. Minden
+     * NEM-scan-summary source érintetlen (×1). READ-time, a nyers `score` (relevancia) változatlan.
+     */
+    scanSummaryFactor(source, weight, scanSummaryWeight) {
+        if (source?.type !== 'scan-summary' || weight <= scanSummaryWeight) {
+            return 1;
+        }
+        return scanSummaryWeight / weight;
+    }
     /**
      * Memory Activation Model decay-szorzó (dsgn-013 §3) — CSAK a `memory` táron, ha engedélyezett. A frissen/gyakran
      * FELIDÉZETT memória felül-, a régóta érintetlen alul-rangsorol, de a `floorWeight > 0` miatt SOSEM esik ki. A
@@ -437,6 +453,7 @@ class FAM_Retrieval_ControlService {
         // finalScore = score × weight × chunkF × sourceF × decayF × (1 + keywordWeight × lexicalScore).
         const chunkFactor = this.chunkTypeFactor(set.entry.chunkType, set.importChunkWeight);
         const sourceFactor = this.importSourceFactor(set.entry.source, set.importSourceWeight);
+        const summaryFactor = this.scanSummaryFactor(set.entry.source, set.weight, set.config.scanSummaryWeight);
         const decayFactor = this.memoryDecayFactor(set.entry, set.table, set.config, set.nowMs);
         const lexicalScore = set.config.keywordWeight > 0
             ? fam_lexical_match_util_1.FAM_LexicalMatch_Util.score(set.queryTerms, {
@@ -449,7 +466,7 @@ class FAM_Retrieval_ControlService {
             table: set.table,
             score: set.vectorHit.score,
             weight: set.weight,
-            finalScore: set.vectorHit.score * set.weight * chunkFactor * sourceFactor * decayFactor * keywordBoost,
+            finalScore: set.vectorHit.score * set.weight * chunkFactor * sourceFactor * summaryFactor * decayFactor * keywordBoost,
             lexicalScore: lexicalScore,
             content: set.includeContent ? set.entry.content : undefined,
             contentHash: set.entry.contentHash,
@@ -655,6 +672,7 @@ class FAM_Retrieval_ControlService {
         const relevanceFloor = await this.resolveNumber(config, 'read.relevanceFloor', ctx, 0.5);
         const importChunkWeight = await this.resolveNumber(config, 'read.importChunkWeight', ctx, 0.4);
         const importSourceWeight = await this.resolveNumber(config, 'read.importSourceWeight', ctx, 0.85);
+        const scanSummaryWeight = await this.resolveNumber(config, 'read.scanSummaryWeight', ctx, 1.0);
         const keywordWeight = await this.resolveNumber(config, 'read.keywordWeight', ctx, 0.6);
         const denseResultRatio = await this.resolveNumber(config, 'read.denseResultRatio', ctx, 2.0);
         const denseResultAbsMin = await this.resolveNumber(config, 'read.denseResultAbsMin', ctx, 25);
@@ -679,6 +697,7 @@ class FAM_Retrieval_ControlService {
             relevanceFloor: relevanceFloor,
             importChunkWeight: importChunkWeight,
             importSourceWeight: importSourceWeight,
+            scanSummaryWeight: scanSummaryWeight,
             keywordWeight: keywordWeight,
             denseResultRatio: denseResultRatio,
             denseResultAbsMin: denseResultAbsMin,

package/package.json

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