@futdevpro/fdp-agent-memory 1.1.115 → 1.1.119

package/build/package.json

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

@@ -55,6 +55,10 @@ exports.SCAN_IGNORE_PATTERNS_DEFAULT = [
     // Cookies / Web Data = SZEMÉLYES adat), olvashatatlanok + junk. (Lelet 2026-06-22: fdp-assistant/__agent/
     // .local-state = 403 MB / 2452 fájl → 2208 `FAM-SCAN-READ-001`. Az `__agent` MAGA MARAD — csak a state junk.)
     '**/.local-state/**', '**/browser-profiles/**', '**/Cache_Data/**',
+    // CSOMAGKEZELŐ content-addressed STORE/cache (2026-07-26 lelet): a repo-lokális `.pnpm-store` a `node_modules`-tól
+    // KÜLÖNÁLLÓ mappa, ezért a `**/node_modules/**` NEM fedte → egyetlen NPM-csomagban 18 881 junk-fájl került a
+    // felderítésbe (fdp-e2e-helpers: 22 618 „forrás"-fájlból 18 881 a store). Sosem forrás — hash-elt tarball-tartalom.
+    '**/.pnpm-store/**', '**/.yarn/cache/**', '**/.yarn/unplugged/**', '**/.pnp.cjs', '**/.pnp.js',
     // A `.fdpfamignore` SAJÁT MAGÁT kizárja: ignore-spec-ként OLVASSUK (FAM_FamIgnore_Util.loadFromDir,
     // a walk/routing megkerülésével), de SOHA nem ingesteljük content-ként (a router amúgy is skip-elné).
     '**/.fdpfamignore',

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

@@ -39,6 +39,12 @@ class FAM_ScanJob_DataModel extends fsm_dynamo_1.DyFM_Metadata {
     resumeCount;
     /** Terminál ok-szöveg (pl. „resume-cap túllépve") — `failed`/`cancelled` job-on, a diagnózishoz. */
     failureReason;
+    /**
+     * KI indította a job-ot (`FAM_AgentOrigin`: agent/sessionId/workspace/label) — **DURABLE** (2026-07-26 lelet: eddig
+     * csak in-memory volt, ezért restart + auto-resume után `origin: undefined` lett → a logból/`listJobs`-ból NEM
+     * derült ki, hogy a HETI AUTO re-scan (`agent:'fam-scheduler'`) futott-e, vagy egy manuális/CLI scan).
+     */
+    origin;
     constructor(set) {
         super(set);
         if (set) {
@@ -69,5 +75,6 @@ exports.famScanJob_dataParams = new fsm_dynamo_1.DyFM_DataModel_Params({
         sourceLocation: { type: 'string' },
         resumeCount: { type: 'number' },
         failureReason: { type: 'string' },
+        origin: { type: 'object' },
     },
 });

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

@@ -46,6 +46,16 @@ class FAM_EmbeddingBootstrap_ControlService {
         catch (error) {
             fsm_dynamo_1.DyFM_Log.warn(`[FAM bootstrap] ENV-config seed sikertelen: ${error?.message}`);
         }
+        // HETI AUTO RE-SCAN + DELETE-SYNC (dispatch „Problem 2", 2026-07-26): az in-process ütemező telepítése MÁR ITT,
+        // a lassú boot-karbantartás (hidratálás/scope/resume/dormancy) ELŐTT — hogy a heti-slot timer BIZTOSAN felkerüljön
+        // az event-loopra, függetlenül attól, meddig tart egy nagy korpusz hidratálása (a `setInterval` az `await`-ok alatt
+        // is tüzel; a lentebbi lépések egyike sem gátolhatja a telepítést). A tick maga vár a hidratálás végéig + best-effort.
+        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}`);
+        }
         // 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 {
@@ -63,6 +73,10 @@ class FAM_EmbeddingBootstrap_ControlService {
         catch (error) {
             fsm_dynamo_1.DyFM_Log.warn(`[FAM bootstrap] vektor-pool hidratálás sikertelen: ${error?.message}`);
         }
+        // A hidratálás UTÁN AZONNAL egy scheduler-tick (fire-and-forget): a heti catch-up így PROMPT lefut a hidratálás
+        // végén (nem kell a 10-perces intervallumra várni), és FÜGGETLEN a lentebbi (potenciálisan lassú) boot-karbantartástól.
+        // A tick maga best-effort + a hidratálás-kaput már átlépte (complete), így itt biztonságosan indíthat re-scant.
+        void fam_scan_scheduler_control_service_1.FAM_ScanScheduler_ControlService.getInstance().tick(Date.now());
         // Scope-integritás self-check (user-FR 2026-06-22): a rendszer MAGÁTÓL ismerje fel az árva/duplikált
         // scope-okat (boot után, best-effort — a takarítás `merge_scopes`, nem itt). Csak figyelmeztet, nem ír.
         try {
@@ -98,15 +112,6 @@ 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.control-service.js

@@ -98,8 +98,13 @@ class FAM_ScanJob_ControlService {
             void this.persistUpdate(job);
             fsm_dynamo_1.DyFM_Log.warn(`[scanJob ${job.jobId}] ${job.failureReason}`);
         });
-        fsm_dynamo_1.DyFM_Log.info(`[scanJob ${job.jobId}] indítva: ${specs.length} projekt, cooldown ${cooldownMs}ms `
-            + `(ha ≥${cooldownMinChunks} embed chunk)`);
+        // INDÍTÁS-LOG (2026-07-26 bővítés — „derüljön ki a logból, KI indította"): az origin (agent/label/session) + a
+        // TELJES cél-lista a log-bufferbe (`.log`, nem `.info` — csak az előbbi pufferelődik a `/api/logs/get`-be).
+        fsm_dynamo_1.DyFM_Log.log(`[scanJob ${job.jobId}] INDÍTVA — indító: ${FAM_ScanJob_ControlService.describeOrigin(job.origin)} `
+            + `| ${specs.length} cél | cooldown ${cooldownMs}ms (ha ≥${cooldownMinChunks} embed chunk)`);
+        specs.forEach((spec, index) => {
+            fsm_dynamo_1.DyFM_Log.log(`[scanJob ${job.jobId}]   cél ${index + 1}/${specs.length}: ${spec.project} → ${spec.path}`);
+        });
         // Fast-path (user-FR 2026-06-22): a `start` legfeljebb `waitMs`-ig (default 15s) megvárja a befejezést — ha
         // a job ennyin belül kész, a TELJES eredményt adjuk vissza AZONNAL (nincs külön poll-hívás); különben a futó
         // job-ot (`jobId` + `running` + ETA) → a hívó poll-oz. `0` = ne várj.
@@ -120,6 +125,26 @@ class FAM_ScanJob_ControlService {
             await fam_cooldown_util_1.FAM_Cooldown_Util.sleep(100);
         }
     }
+    /**
+     * Az INDÍTÓ ember-olvasható leírása a logokhoz (2026-07-26): `agent[/label][ · session]`. Aláírás nélküli (régi/
+     * kézi) job → `ismeretlen (aláíratlan)` — hogy a log EXPLICIT jelezze: nem tudjuk, ki indította (nem „hallgat").
+     */
+    static describeOrigin(origin) {
+        if (!origin || (!origin.agent && !origin.label && !origin.sessionId)) {
+            return 'ismeretlen (aláíratlan)';
+        }
+        const label = origin.label ? `/${origin.label}` : '';
+        const session = origin.sessionId ? ` · session ${String(origin.sessionId).slice(0, 8)}` : '';
+        return `${origin.agent ?? 'ismeretlen-agent'}${label}${session}`;
+    }
+    /**
+     * Van-e AKTÍV (running/pending) scan-job? A heti auto-re-scan SINGLE-FLIGHT kapuja (2026-07-26 lelet: restart +
+     * auto-resume mellett HÁROM egyidejű 13-célos job futott) — soha ne indítsunk párhuzamos TELJES scant (a
+     * hidratált pool + embed erőforrás-kontenció miatt ez a gépet is megfoghatja).
+     */
+    hasActiveJob() {
+        return Array.from(this.jobs.values()).some((job) => job.status === 'running' || job.status === 'pending');
+    }
     /** Egy job állapota (poll). `undefined`, ha ismeretlen (a hívó 404-et ad). Az ETA + stall frissítve. */
     getStatus(jobId) {
         const job = this.jobs.get(jobId);
@@ -214,7 +239,8 @@ class FAM_ScanJob_ControlService {
                 job.finishedAt = Date.now();
                 job.failureReason = `felhasználói megszakítás a(z) ${index + 1}/${specs.length} projektnél`;
                 await this.persistUpdate(job);
-                fsm_dynamo_1.DyFM_Log.info(`[scanJob ${job.jobId}] ${job.failureReason}`);
+                fsm_dynamo_1.DyFM_Log.log(`[scanJob ${job.jobId}] MEGSZAKÍTVA — ${job.failureReason} | indító: `
+                    + `${FAM_ScanJob_ControlService.describeOrigin(job.origin)}`);
                 return;
             }
             // RESUME (FEAT-008 Phase 4): a már `ok` projekteket ÁTUGORJUK (a megszakítási ponttól folytatunk —
@@ -227,7 +253,11 @@ class FAM_ScanJob_ControlService {
             job.lastProgressAt = Date.now(); // egy projekt feldolgozásának KEZDETE is haladás (a stall-óra resetelődik)
             // Per-projekt PROGRESS a process-logba (user-FR 2026-06-25 — „hanyadik projektből hányadikon járunk"): a
             // detached FAM-ablakot figyelve egyből látszik a pozíció (`[12/48] <projekt>`), nem kell a REST-et poll-ozni.
-            fsm_dynamo_1.DyFM_Log.info(`[scanJob ${job.jobId}] [${index + 1}/${specs.length}] ${specs[index].project} — feldolgozás…`);
+            // `.log` (NEM `.info`) — a DyNTS log-buffer (`/api/logs/get`) CSAK a `.log`/`.warn`-t puffereli, ezért a
+            // `.info` kontextus-sorok korábban LÁTHATATLANOK voltak a log-lekérdezésben (2026-07-26 lelet: a user a
+            // `[famIngest] … feldolgozás` sort látta, de azt NEM, hogy melyik job/indító/cél-index tartozik hozzá).
+            fsm_dynamo_1.DyFM_Log.log(`[scanJob ${job.jobId}] [cél ${index + 1}/${specs.length}] ${specs[index].project} `
+                + `(${specs[index].path}) — feldolgozás indul | indító: ${FAM_ScanJob_ControlService.describeOrigin(job.origin)}`);
             const result = await runner(specs[index]);
             job.projects[index] = result;
             job.lastProgressAt = Date.now(); // per-target BEFEJEZÉS → friss haladás-jel a stall-detekciónak
@@ -252,7 +282,9 @@ class FAM_ScanJob_ControlService {
         job.status = 'completed';
         job.finishedAt = Date.now();
         await this.persistUpdate(job);
-        fsm_dynamo_1.DyFM_Log.info(`[scanJob ${job.jobId}] KÉSZ: ${job.okCount}/${specs.length} ok`);
+        fsm_dynamo_1.DyFM_Log.log(`[scanJob ${job.jobId}] KÉSZ: ${job.okCount}/${specs.length} ok | indító: `
+            + `${FAM_ScanJob_ControlService.describeOrigin(job.origin)} | teljes futásidő `
+            + `${Math.round(((job.finishedAt ?? Date.now()) - job.startedAt) / 1000)}s`);
     }
     /** A job durable rekordjának LÉTREHOZÁSA (best-effort — a perzisztencia hibája nem buktatja a scant). */
     async persistCreate(job, specs, sourceLocation) {
@@ -262,6 +294,9 @@ class FAM_ScanJob_ControlService {
                 okCount: job.okCount, cooldownMs: job.cooldownMs, cooldownMinChunks: job.cooldownMinChunks,
                 startedAt: job.startedAt, projects: job.projects, specs: specs, sourceLocation: sourceLocation,
                 resumeCount: job.resumeCount ?? 0,
+                // KI indította — DURABLE-be is (2026-07-26 lelet): eddig csak in-memory volt, ezért a `listJobs`/log a
+                // restart+auto-resume után `origin: undefined`-ot mutatott → NEM derült ki, hogy a heti AUTO-scan futott-e.
+                origin: job.origin,
             }));
         }
         catch (error) {
@@ -316,6 +351,9 @@ class FAM_ScanJob_ControlService {
                     resumeCount: priorResumes + 1,
                     cancelRequested: false,
                     projects: doc.projects ?? doc.specs.map((spec) => ({ project: spec.project, path: spec.path, status: 'pending' })),
+                    // Az INDÍTÓ visszaállítása a durable rekordból — így a resume-olt job is beazonosítható (heti
+                    // AUTO-scan vs manuális); enélkül a restart „elmosta" az origint (2026-07-26 lelet).
+                    origin: doc.origin,
                 };
                 this.jobs.set(job.jobId, job);
                 this.stallThresholdMsByJob.set(job.jobId, stallThresholdMs);
@@ -323,7 +361,8 @@ class FAM_ScanJob_ControlService {
                 // számról indul → a cap konvergál; különben egy crash-loop sosem érné el a capet).
                 await dataService.updateJobByJobId(job.jobId, { resumeCount: job.resumeCount });
                 const doneCount = job.projects.filter((project) => project.status === 'ok').length;
-                fsm_dynamo_1.DyFM_Log.info(`[scanJob ${job.jobId}] RESUME (${job.resumeCount}/${maxResumeCount}): ${doneCount}/${job.total} kész — folytatás a megszakítási ponttól`);
+                fsm_dynamo_1.DyFM_Log.log(`[scanJob ${job.jobId}] RESUME (${job.resumeCount}/${maxResumeCount}) — eredeti indító: `
+                    + `${FAM_ScanJob_ControlService.describeOrigin(job.origin)} | ${doneCount}/${job.total} kész — folytatás a megszakítási ponttól`);
                 void this.process(job, doc.specs).catch((error) => {
                     job.status = 'failed';
                     job.finishedAt = Date.now();

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

@@ -31,20 +31,31 @@ class FAM_ScanJob_DataService extends nts_dynamo_1.DyNTS_DataService {
         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`.
+     * A KORÁBBAN SZKENNELT célok UNIÓJA a durable scan-job előzményből (weekly re-scan auto-derive, 2026-07-26). A
+     * `startedAt` szerint csökkenő rendben végigmegy a legutóbbi job-okon, és `path` szerint deduplikálva gyűjti a
+     * cél-specjeket — a FRISSEBB job spec-je nyer (az aktuálisabb scope/table beállítással).
+     *
+     * **Miért unió és nem „a legutóbbi job listája"?** (2026-07-26 lelet) A legutóbbi job gyakran RÉSZLEGES (pl. csak
+     * 13 NPM-csomag), így a „heti TELJES re-scan" valójában nem lett volna teljes — az azelőtt szkennelt projektek
+     * kimaradtak volna, és a törlés-szinkron sem futott volna rájuk. Az unió a „mindent, amit valaha szkenneltünk"
+     * közelítése. (A garantáltan teljes lefedettség továbbra is az 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 });
+        const found = await this.searchData({ sortBy: [{ key: 'startedAt', order: -1 }], pageSize: 100 });
+        const byPath = new Map();
         for (const job of found.results ?? []) {
             const specs = job.specs;
-            if (specs && specs.length) {
-                return specs;
+            for (const spec of specs ?? []) {
+                const key = String(spec?.path ?? '').trim().toLowerCase();
+                // A frissebb job ELŐBB jön (startedAt desc) → az első találat a legfrissebb; a régebbit nem írjuk felül.
+                if (key && !byPath.has(key)) {
+                    byPath.set(key, spec);
+                }
             }
         }
-        return undefined;
+        return byPath.size ? Array.from(byPath.values()) : undefined;
     }
 }
 exports.FAM_ScanJob_DataService = FAM_ScanJob_DataService;

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

@@ -6,6 +6,7 @@ const fam_config_level_type_enum_1 = require("../../../_enums/fam-config-level.t
 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");
+const embedding_1 = require("../../embedding");
 /**
  * `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
@@ -13,6 +14,10 @@ const fam_scan_job_data_service_1 = require("./fam-scan-job.data-service");
  * 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).
+ * **Telepítés (KRITIKUS):** a `boot()` a scheduler-t a LEHETŐ LEGKORÁBBAN (a lassú boot-karbantartás — hidratálás/scope-
+ * integritás/resume/dormancy — ELŐTT) telepíti, hogy a timer BIZTOSAN felkerüljön az event-loopra, függetlenül attól,
+ * hogy egy nagy korpusz hidratálása/karbantartása meddig tart (a `setInterval` az `await`-ok alatt is tüzel). A tick
+ * viszont a **hidratálás befejeztéig NEM indít re-scant** (erőforrás-kontenció ellen) — a következő tick bepótol.
  * **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.
@@ -26,6 +31,8 @@ class FAM_ScanScheduler_ControlService {
     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;
+    /** Nap-nevek a logokhoz (a `getDay()` 0=vasárnap indexelése szerint) — hogy a log ember-olvasható legyen. */
+    static DAY_NAMES = ['vasárnap', 'hétfő', 'kedd', 'szerda', 'csütörtök', 'péntek', 'szombat'];
     static getInstance() {
         if (!FAM_ScanScheduler_ControlService._instance) {
             FAM_ScanScheduler_ControlService._instance = new FAM_ScanScheduler_ControlService();
@@ -50,7 +57,7 @@ class FAM_ScanScheduler_ControlService {
         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).`);
+        fsm_dynamo_1.DyFM_Log.log(`[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). */
@@ -74,17 +81,43 @@ class FAM_ScanScheduler_ControlService {
             const config = config_control_service_1.FAM_Config_ControlService.getInstance();
             const enabled = (await config.resolve('scan.weeklyRescanEnabled')).value;
             if (enabled === false) {
+                fsm_dynamo_1.DyFM_Log.log('[FAM scanScheduler] heti re-scan KIKAPCSOLVA (`scan.weeklyRescanEnabled=false`) — kihagyva.');
+                return;
+            }
+            // HIDRATÁLÁS-KAPU: a scheduler-t a boot ELEJÉN telepítjük (nem a lassú boot-karbantartás mögött), ezért a
+            // tick a hidratálás ALATT is tüzelhet — de ILYENKOR NE indítsunk TELJES re-scant (erőforrás-kontenció a
+            // 100k+ vektor hidratálásával). Nem rögzítünk lastRun-t → a következő tick (a hidratálás után) BEPÓTOL.
+            const hydration = embedding_1.FAM_VectorSearch_ControlService.getInstance().hydrationSummary();
+            if (!hydration.complete) {
+                fsm_dynamo_1.DyFM_Log.log(`[FAM scanScheduler] hidratálás MÉG FOLYAMATBAN (${hydration.hydratedTables}/${hydration.totalTables} tár, `
+                    + `vár: ${hydration.pendingTables.join(', ')}) — a heti re-scan most kihagyva, a következő tick bepótol.`);
                 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);
+            const iso = (ms) => (ms > 0 ? new Date(ms).toISOString() : 'SOHA');
             if (lastRun >= slot) {
-                return; // e heti slot óta már futott (vagy még nem jött el a slot)
+                // NEM esedékes — a döntést + a MIÉRT-et is logoljuk (a user kérése: derüljön ki a logból; a következő
+                // slot időpontjával, hogy látható legyen, mikor futna legközelebb).
+                fsm_dynamo_1.DyFM_Log.log(`[FAM scanScheduler] heti re-scan NEM esedékes — utolsó futás ${iso(lastRun)} ≥ aktuális heti `
+                    + `slot ${iso(slot)} (slot: ${FAM_ScanScheduler_ControlService.DAY_NAMES[day] ?? day} ${hour}:00). `
+                    + `Következő slot: ${iso(slot + 7 * 24 * 3600000)}.`);
+                return;
             }
-            // 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.
+            // SINGLE-FLIGHT (2026-07-26 lelet — „max heti 1x, ÚJRAINDULÁSTÓL FÜGGETLENÜL"): ha MÁR fut egy scan-job
+            // (pl. a boot auto-resume folytatta a megszakadt heti scant), NE indítsunk MÉG EGYET. Nem rögzítünk
+            // lastRun-t → ha a futó job nem a heti volt, a következő tick újra megvizsgálja.
+            if (fam_scan_job_control_service_1.FAM_ScanJob_ControlService.getInstance().hasActiveJob()) {
+                fsm_dynamo_1.DyFM_Log.log('[FAM scanScheduler] heti re-scan esedékes lenne, DE MÁR FUT egy scan-job '
+                    + '(single-flight kapu) — most kihagyva, a következő tick újrapróbálja.');
+                return;
+            }
+            // DUE: ELŐBB rögzítjük a lastRun-t (így egy crash/restart mid-scan sem indít újra minden bootkor — ez a
+            // „max heti 1x, újraindulástól függetlenül" garanciájának a MAGJA), MAJD indítjuk a scant.
+            fsm_dynamo_1.DyFM_Log.log(`[FAM scanScheduler] heti re-scan ESEDÉKES — utolsó futás ${iso(lastRun)} < heti slot ${iso(slot)} `
+                + `(slot: ${FAM_ScanScheduler_ControlService.DAY_NAMES[day] ?? day} ${hour}:00). Indítás…`);
             await this.markRan(config, nowMs);
             await this.triggerRescan();
         }
@@ -102,15 +135,24 @@ class FAM_ScanScheduler_ControlService {
         const rootValue = (await config.resolve('scan.weeklyRescanRoot')).value;
         const root = typeof rootValue === 'string' ? rootValue.trim() : '';
         if (root) {
+            fsm_dynamo_1.DyFM_Log.log(`[FAM scanScheduler] cél-forrás: EXPLICIT \`scan.weeklyRescanRoot\` = ${root} `
+                + '(a root alatt felderített ÖSSZES projekt — teljes lefedettség).');
             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}).`);
+            fsm_dynamo_1.DyFM_Log.log(`[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).
+        // Zero-config: a KORÁBBAN SZKENNELT célok UNIÓJA (nem csak a legutóbbi job listája — 2026-07-26 lelet: a
+        // „legutóbbi job" egy RÉSZLEGES lista volt (13 NPM-csomag), így a „TELJES re-scan" nem volt teljes).
         const targets = await this.loadLatestScannedTargets();
         if (targets && targets.length) {
+            fsm_dynamo_1.DyFM_Log.log(`[FAM scanScheduler] cél-forrás: ZERO-CONFIG — a korábban szkennelt célok uniója a durable `
+                + `scan-job előzményből (${targets.length} cél). FIGYELEM: ez CSAK azt fedi, amit már szkenneltünk; a `
+                + 'garantáltan TELJES lefedettséghez állítsd be a `scan.weeklyRescanRoot`-ot a workspace-gyökérre.');
+            targets.forEach((spec, index) => {
+                fsm_dynamo_1.DyFM_Log.log(`[FAM scanScheduler]   cél ${index + 1}/${targets.length}: ${spec.project} → ${spec.path}`);
+            });
             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).`);
+            fsm_dynamo_1.DyFM_Log.log(`[FAM scanScheduler] heti TELJES re-scan + reconcile INDÍTVA (${targets.length} cél, zero-config unió).`);
             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 '

package/package.json

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