@futdevpro/fdp-agent-memory 1.1.30 → 1.1.113

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

@@ -66,9 +66,37 @@ function registerFAMCommands(program, version) {
     ];
     for (const command of famCommands) {
         applyExitMapping(command);
+        if (SERVER_DEPENDENT_COMMANDS.has(command.name())) {
+            attachEnsureServerHook(command);
+        }
         program.addCommand(command);
     }
 }
+/**
+ * A szerver-függő (REST-et hívó) data-parancsok — ezekre rákötjük az auto-ensure pre-action hook-ot (user-FR
+ * 2026-06-22: „minden fam funkciónak gondoskodnia kell a fam elindításáról"). A környezet-szintű parancsok
+ * (`init`/`doctor`/`validate-env`/…) É a szerver-életciklust kezelő `start`/`serve` KIMARADNAK (azok nem a
+ * futó primary-t hívják, vagy MAGUK a szerver).
+ */
+const SERVER_DEPENDENT_COMMANDS = new Set([
+    'read', 'write', 'scan', 'scan-projects', 'import', 'export', 'capture',
+    'config', 'stats', 'find-duplicates', 'errors', 'migrate', 'seed-example',
+]);
+/**
+ * Az auto-ensure pre-action hook rákötése egy szerver-függő parancsra (a commander a hook-ot a parancs ÉS
+ * az al-parancsai action-jére is meghívja, így a `config get`/`import claude-mem` is fedett). Best-effort: ha
+ * az ensure elhasal, a parancs a SAJÁT `unreachable` hibáját adja (no-silent-failure, dsgn-008) — nem dob itt.
+ */
+function attachEnsureServerHook(command) {
+    command.hook('preAction', async () => {
+        try {
+            await serve_command_1.FAM_Serve_Util.ensureRunning();
+        }
+        catch {
+            /* best-effort auto-ensure — a tényleges elérhetetlenséget a parancs HTTP-rétege jelzi tiszta hibával */
+        }
+    });
+}
 /**
  * A dsgn-010 §3 exit-kód-mapping rákötése egy FAM parancsra ÉS minden al-parancsára (rekurzívan): a
  * commander használati/argument-hibái `2`-vel lépnek ki (a parancs-handler-ek `0`/`1`/`3` kódjait a

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

@@ -26,6 +26,11 @@ const GLOBAL_ONLY = [fam_config_level_type_enum_1.FAM_ConfigLevel.global];
  */
 exports.SCAN_IGNORE_PATTERNS_DEFAULT = [
     '**/node_modules/**', '**/.git/**', '**/build/**', '**/dist/**', '**/coverage/**',
+    // Workspace-szintű HARD-kizárás (user-direktíva 2026-06-24, KRITIKUS — „SEMMIT nem akarunk szkennelni, ami a
+    // Stale-ben van!!!"). Az archív/elavult projektek (`STALE-projects/`, pl. `fury`) + a sablon-junk
+    // (`TEMPLATE-projects/`, `{{PROJECT_NAME}}`) SOHA nem korpusz-anyag — még explicit cél-útvonalon sem. (A
+    // felderítés külön, garantáltan kihagyja őket: FAM_ProjectDiscovery_Util.SKIP_DIRS.)
+    '**/STALE-projects/**', '**/TEMPLATE-projects/**',
     // Framework build-/futás-cache + generált kimenet (FAM-REV-056) — sosem forrás, gyakran minifikált/bináris-
     // szerű (pl. az Angular `.angular/cache/.../babel-webpack` ezreket számláló, embed-timeout-ot okozó junk-ja).
     '**/.angular/**', '**/.nx/**', '**/.cache/**', '**/.turbo/**', '**/.next/**', '**/.nuxt/**', '**/.svelte-kit/**',
@@ -45,6 +50,11 @@ exports.SCAN_IGNORE_PATTERNS_DEFAULT = [
     // lowercase NEM matchelné a Unity `Logs/`-át).
     '**/Library/**', '**/Temp/**', '**/Obj/**', '**/obj/**', '**/bin/**', '**/Logs/**', '**/Build/**', '**/Builds/**',
     '**/.vs/**', '**/*.csproj', '**/*.sln', '**/*.meta', '**/*.unity', '**/*.prefab', '**/*.asset',
+    // Agent-/böngésző-state (lokális futás-melléktermék, SOHA nem korpusz-anyag): `.local-state` (pl. agent
+    // browser-automation profil) + Chromium-profil/cache — lockolt SQLite + bináris blobok (Login Data /
+    // Cookies / Web Data = SZEMÉLYES adat), olvashatatlanok + junk. (Lelet 2026-06-22: fdp-assistant/__agent/
+    // .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/**',
     // 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',
@@ -69,13 +79,35 @@ exports.CONFIG_CATALOG = {
         description: 'A topK effektív felső korlátja (CCAP DEFAULT_PAGE_SIZE=50, cap 500).',
     },
     'read.maxTokens': {
-        type: 'number', default: 6000, min: 256, max: 32000, integer: true, levels: ALL_LEVELS,
-        description: 'Az agent context védelme (max token a read-válaszban).',
+        type: 'number', default: 4000, min: 256, max: 32000, integer: true, levels: ALL_LEVELS,
+        description: 'Az agent context védelme + a read-válasz INLINE-tartása (max token; ~4 char/token). A read-tool '
+            + 'ÉRVÉNYESÍTI (FAM-REV: korábban dead-config volt → korlátlan hit-tartalom → a host fájlba mentette a választ). '
+            + 'A budget felett a hit-tartalom levágódik + a túlcsorduló hit-ek elhagyva (`truncated:true`).',
+    },
+    'write.dedupWarnEnabled': {
+        type: 'boolean', default: true, levels: ALL_LEVELS,
+        description: 'Near-duplikátum-FIGYELMEZTETÉS íráskor (user-FR 2026-06-25): a `create` UTÁN a friss vektorral '
+            + 'megkeresi a tár legközelebbi szomszédait; ha valamelyik a `write.dedupWarnThreshold` FÖLÖTT van, a write-'
+            + 'válasz `warnings`-ába kerül („majdnem ugyanaz, mint X — érdemes UPDATE-elni"). NEM blokkol (a duplikáció-'
+            + 'keletkezés megelőzése). `false` → nincs ellenőrzés (nulla extra munka, mert a friss vektor úgyis kész).',
+    },
+    'write.dedupWarnThreshold': {
+        type: 'number', default: 0.93, min: 0.5, max: 1.0, levels: ALL_LEVELS,
+        description: 'A near-duplikátum-warning koszinusz-küszöbe (0..1; default 0.93): e FÖLÖTT egy meglévő entry '
+            + '„majdnem azonosnak" számít az új tartalommal → figyelmeztetés. Magasabb = csak a szinte-teljes egyezésre '
+            + 'jelez; alacsonyabb = agresszívebb (több figyelmeztetés). CSAK jelzés, sosem blokkol.',
     },
     'read.minScore': {
         type: 'number', default: 0.0, min: 0.0, max: 1.0, levels: ALL_LEVELS,
         description: 'Minimum similarity-score küszöb (CCAP default 0 = nincs vágás).',
     },
+    'read.hydrationWaitMs': {
+        type: 'number', default: 180000, min: 0, max: 600000, integer: true, levels: ALL_LEVELS,
+        description: 'A readiness-coordinator hidratálás-bevárás felső korlátja ms-ban: a `read`/`search` MEGVÁRJA a '
+            + 'tár pool-jának (kezdő VAGY újra-) hidratálását ahelyett, hogy `FAM-VEC-SEARCH-001 pool ÜRES`-t dobna. '
+            + '0 = nincs várakozás (azonnali hiba, ha még nem kész). Boot-kor a ~290k-vektor hidratálás percekig tarthat → '
+            + 'a default 180s ezt fedi; time-out után tiszta „még hidratál, próbáld újra" hiba (a következő hívás már kész).',
+    },
     'read.relevanceFloor': {
         type: 'number', default: 0.5, min: 0.0, max: 1.0, levels: ALL_LEVELS,
         description: 'Confidence-padló a nyers cosine score-on: a relevancia-JELZÉSEK (totalRelevant / '
@@ -92,6 +124,34 @@ exports.CONFIG_CATALOG = {
             + 'importChunkWeight` a definíció-chunkok ALÁ rangsorolja őket. READ-time (nincs re-embed); a nyers '
             + 'cosine score (relevancia-jelzések) NEM változik, csak a ranking. 1 = nincs csökkentés.',
     },
+    'read.importSourceWeight': {
+        type: 'number', default: 0.85, min: 0.0, max: 1.0, levels: ALL_LEVELS,
+        description: 'Az import-FORRÁSÚ (`source.type:"import"`, pl. claude-mem-import) entry-k read-idejű rangsor-'
+            + 'szorzója (R2, 2026-06-22 eval-lelet). A `memory`/`knowledge` táron a 33k import ZAJA elnyomta a kurált '
+            + '(`manual`/`agent`/scan) tanulságokat → e szorzóval (`finalScore × importSourceWeight`) a kurált FÖLÉ '
+            + 'rangsorol. READ-time (nincs re-embed); a nyers cosine NEM változik, csak a ranking. 1 = kikapcsolva.',
+    },
+    'read.keywordWeight': {
+        type: 'number', default: 0.6, min: 0.0, max: 5.0, levels: ALL_LEVELS,
+        description: 'Hibrid LEXIKAI (keyword/term-overlap) boost súlya (Improvement 2, eval-lelet 2026-06-25): a tiszta-'
+            + 'vektor `read` ELVÉTI a literal-keyword választ (a koszinusz alacsony a query-megfogalmazásra; a `grep` '
+            + 'azonnal hozza). A finalScore-t `× (1 + keywordWeight × lexicalScore)` szorzóval BOOST-only emeli, ahol a '
+            + 'lexicalScore (0..1) a query disztinktív term-jeinek átfedése az entry szövegével (content+heading+forrás-út). '
+            + '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).',
@@ -104,6 +164,77 @@ exports.CONFIG_CATALOG = {
         type: 'string', default: 'weighted', enumValues: ['weighted', 'raw', 'recency'], levels: ALL_LEVELS,
         description: 'Score-rendezés módja (súlyozott / nyers / recency).',
     },
+    // --- 4.1b. Memory Activation Model — decay/reactivation/dormancy (fogyasztó: dsgn-013) ---
+    'memory.activationEnabled': {
+        type: 'boolean', default: true, levels: ALL_LEVELS,
+        description: 'Memory Activation Model (dsgn-013): a felidézés-alapú lazy-decay rangsor-szorzó a `memory` táron. '
+            + 'A frissen/gyakran FELIDÉZETT memória felül-, a régóta érintetlen alul-rangsorol (de sosem tűnik el, '
+            + 'csak kisebb a súlya). `false` → a decay-mentes (mai) viselkedés. CSAK a memory tárra hat.',
+    },
+    'memory.decayHalfLifeDays': {
+        type: 'number', default: 90, min: 1, max: 3650, integer: true, levels: ALL_LEVELS,
+        description: 'A recency-decay FELEZŐDÉSI ideje napban (Ebbinghaus-görbe, dsgn-013 §2): ennyi nap inaktivitás '
+            + '(nem-felidézés) után a recency-faktor a felére csökken. Nagyobb = lassabb felejtés. Default 90.',
+    },
+    'memory.floorWeight': {
+        type: 'number', default: 0.05, min: 0, max: 1, levels: ALL_LEVELS,
+        description: 'A memória-decay ALSÓ KORLÁTJA (dsgn-013 §2): az effektív szorzó sosem esik ez alá → a régi memória '
+            + 'lesüllyed a rangsorban, de a vektor-keresésben MÉG MEGTALÁLHATÓ (`> 0` → a `weight ≤ 0 → kizárt` szabályt '
+            + 'nem lépi át). `0` = a degradáció akár teljesen elnyomhat (de a tartalom akkor is megmarad Mongo-ban).',
+    },
+    'memory.maxFrequencyBoost': {
+        type: 'number', default: 2.5, min: 1, max: 100, levels: ALL_LEVELS,
+        description: 'A felidézés-gyakoriság (frequency) rangsor-boost FELSŐ KORLÁTJA (eval-lelet 2026-06-25): a nyers '
+            + '`1 + log2(1+recallCount)` KORLÁTLAN (gyakran-felidézett entry-re ~5×), ami multiplikatívan elnyomja a '
+            + 'koszinusz-relevanciát (a „forró" de alig-releváns memória eltemeti a releváns „hideget"). Itt plafonozzuk. '
+            + 'Default 2.5. Nagyobb = a gyakoriság erősebben rangsorol (a régi korlátlan viselkedéshez állítsd magasra).',
+    },
+    'memory.activationWeight': {
+        type: 'number', default: 0.35, min: 0, max: 1, levels: ALL_LEVELS,
+        description: 'Az aktiváció-szorzó TEMPER-súlya (α, eval-lelet 2026-06-25): a nyers decay-szorzót az 1 felé húzza '
+            + '(`1 + α·(raw−1)`) → az aktiváció FINOMAN modulál, a koszinusz-RELEVANCIA dominál (de a recent/frequent még '
+            + 'kissé előrébb). MINDKÉT véglet kompresszálódik: a „forró" entry nem boostolódik túl, ÉS a releváns „hideg" '
+            + 'entry nem zuhan a floor-ra. `1` = a régi (temper-mentes) viselkedés. Default 0.35.',
+    },
+    'memory.reactivateOnRead': {
+        type: 'boolean', default: true, levels: ALL_LEVELS,
+        description: 'Reaktiváció-on-read (dsgn-013 §4): a `read` által VISSZAADOTT memory-hitek „új energiát kapnak" '
+            + '(lastRecalledAt=most, recallCount++, dormant=false) — a felidézés megerősíti az emléket (feljebb rangsorol, '
+            + 'és ha alvó volt, visszakerül a hot készletbe). Async, NEM blokkolja a read-et. `false` → nincs frissítés.',
+    },
+    'memory.dormancyEnabled': {
+        type: 'boolean', default: true, levels: GLOBAL_ONLY,
+        description: 'Dormancy (dsgn-013 §5): a régóta-nem-felidézett, ritkán-használt memóriák ALVÓ-vá jelölése — NEM '
+            + 'hidratálódnak a hot LVS-poolba (RAM-/boot-spórolás), de COLD (Mongo) kereséssel elérhetők + megtaláláskor '
+            + 'reaktiválódnak. SOHA nem törlés. `false` → minden memória hidratálódik (a mai viselkedés).',
+    },
+    'memory.dormantMinAgeDays': {
+        type: 'number', default: 180, min: 1, max: 3650, integer: true, levels: GLOBAL_ONLY,
+        description: 'A DORMANT-küszöb minimális inaktivitása napban (dsgn-013 §5.1): egy memória CSAK akkor lehet alvó, '
+            + 'ha legalább ennyi napja nem idéztük fel (biztonsági alsó kor — a friss memória sosem alvó). Default 180.',
+    },
+    'memory.dormantMaxRecallCount': {
+        type: 'number', default: 2, min: 0, max: 1000, integer: true, levels: GLOBAL_ONLY,
+        description: 'A DORMANT-küszöb recall-gátja (dsgn-013 §5.1): a memória CSAK akkor lehet alvó, ha ennél kevesebbszer '
+            + 'idéztük fel — a gyakran-használt (≥ ennyi recall) memória SOHA nem alvó. Default 2.',
+    },
+    'memory.coldSearchEnabled': {
+        type: 'boolean', default: true, levels: ALL_LEVELS,
+        description: 'Cold-search (dsgn-013 §5.3): ha egy memória-read a HOT poolból kevés találatot ad (a dormant entry-k '
+            + 'nincsenek ott), a dormant készleten Mongo-oldali koszinusz-keresés fut (lassabb, de teljes), és a talált '
+            + 'entry-ket REAKTIVÁLJA (visszakerülnek a hot készletbe). `false` → a dormant entry-k csak re-scan/aktiváláskor jönnek vissza.',
+    },
+    'memory.coldSearchMaxCandidates': {
+        type: 'number', default: 5000, min: 100, max: 100000, integer: true, levels: ALL_LEVELS,
+        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.',
+    },
+    '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 '
+            + 'átírt tartalma (pl. kompaktált MEMORY.md korábbi bejegyzései) ezzel a szorzóval süllyed a rangsorban — a friss '
+            + 'verzió fölébe kerül, de a régi MEGMARAD (cold-kereshető). `1` = nincs penalty; `0` = teljesen elnyomott (de megőrzött).',
+    },
     // --- 4.2. Chunking — fájl-típusonként (fogyasztó: dsgn-004) ---
     'chunk.ts.maxSize': {
         type: 'number', default: 1500, min: 200, max: 8000, integer: true, levels: ALL_LEVELS,
@@ -236,10 +367,19 @@ exports.CONFIG_CATALOG = {
             + 'KÖZÖTT vár (az utolsó után nem), és a `dryRun` NEM vár (nincs valódi embed-munka).',
     },
     'scan.projectCooldownMs': {
-        type: 'number', default: 0, min: 0, max: 60000, integer: true, levels: ALL_LEVELS,
-        description: 'Kikapcsolható cooldown (ms) a PROJEKTEK KÖZÉ a `scan-projects` soros multi-scan-jében — a sok-'
-            + 'projektes (L2/L6) beolvasás ne thrash-elje a gépet. Default `0` = KIKAPCSOLVA; nagy futásra pl. 2000–'
-            + '5000. A CLI `--cooldown <ms>` felülírja ezt a config-default-ot (a projektek KÖZÖTT vár, az utolsó után nem).',
+        type: 'number', default: 10000, min: 0, max: 60000, integer: true, levels: ALL_LEVELS,
+        description: 'Cooldown (ms) a PROJEKTEK KÖZÉ a `scan-projects` soros multi-scan-jében — a sok-projektes '
+            + '(L2/L6) beolvasás ne thrash-elje a gépet. Default `10000` (10s). FELTÉTELES (user-FR 2026-06-22): CSAK '
+            + 'akkor vár, ha az ELŐZŐ projekt VALÓDI embed-munkát végzett (≥ `scan.projectCooldownMinChunks` új+módosult '
+            + 'chunk) — ha minden `equal` volt (0 embed), nincs gép-terhelés → NINCS cooldown. `0` = teljesen KI. A CLI '
+            + '`--cooldown <ms>` felülírja. (A projektek KÖZÖTT vár, az utolsó után nem.)',
+    },
+    'scan.projectCooldownMinChunks': {
+        type: 'number', default: 100, min: 0, max: 100000, integer: true, levels: ALL_LEVELS,
+        description: 'A feltételes projekt-cooldown küszöbe (user-FR 2026-06-22): a `scan-projects` CSAK akkor vár a '
+            + 'projektek között, ha az előző projekt ennyi VAGY több új+módosult (ténylegesen embeddelt) chunkot termelt. '
+            + 'Default `100` — a kis/`equal`-csak projektek után nincs felesleges szünet (a cooldown a helyi embed-terhelés '
+            + 'tehermentesítésére van). `0` = mindig vár (ha a cooldownMs > 0).',
     },
     'scan.estimateMsPerChunk': {
         type: 'number', default: 250, min: 1, max: 10000, integer: true, levels: ALL_LEVELS,
@@ -251,6 +391,20 @@ exports.CONFIG_CATALOG = {
         description: 'A futás-közbeni scan-progress log min. időköze (ms) — a nagy scan haladását ennyente jelzi '
             + 'a konzolon (`[famIngest]` activity-sor). A végső 100% mindig kibocsátódik.',
     },
+    'scan.stallThresholdMs': {
+        type: 'number', default: 120000, min: 5000, max: 1800000, integer: true, levels: ALL_LEVELS,
+        description: 'STALL-küszöb (ms, FEAT-008 Phase 5 — „jobb job kezelés"): ha egy FUTÓ scan-job ennyi ideje nem '
+            + 'mutat haladást (sem per-target befejezés, sem within-target progress), a `status`-ban `stalled:true` jelenik '
+            + 'meg. CSAK JELZÉS (nem szakítja meg automatikusan) — a user/CLI dönt (poll tovább / `cancel`). Az LM Studio '
+            + 'crash/hang determinisztikus felismeréséhez. Default `120000` (2 perc).',
+    },
+    'scan.maxResumeCount': {
+        type: 'number', default: 5, min: 0, max: 100, integer: true, levels: ALL_LEVELS,
+        description: 'AUTO-RESUME cap (FEAT-008 Phase 5): egy megszakadt job-ot a szerver legfeljebb ennyiszer indít újra '
+            + 'a startup-resume-on. Efölött a job `failed` (failureReason="resume-cap túllépve") — így egy folyton-elakadó '
+            + '(pl. mindig ugyanazon a tartalmon összeomló) job nem indul újra a végtelenségig minden restartkor. `0` = '
+            + 'soha ne resume-olj automatikusan.',
+    },
     // --- 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/_collections/error-codes.const.js

@@ -111,6 +111,8 @@ exports.FAM_ERROR_CODES = {
     // --- Vector (FAM-VEC-*) ---
     /** Mongo→in-memory pool hidratálás sikertelen boot-on (BFR-AM-001). */
     vecHydrate: 'FAM-VEC-HYDRATE-001',
+    /** A hidratálás-bevárás (readiness-coordinator) hibája: a tár hidratálása MEGBUKOTT vagy a várakozás time-outolt. */
+    vecHydrateWait: 'FAM-VEC-HYDRATE-002',
     /** vectorSearch hiba (dimenzió / üres pool / searchMode). */
     vecSearch: 'FAM-VEC-SEARCH-001',
     /** contentVector Mongo-persist sikertelen (BFR-AM-005). */

package/build/src/_collections/fam-console.util.js

@@ -8,55 +8,25 @@ const os = tslib_1.__importStar(require("os"));
 const path = tslib_1.__importStar(require("path"));
 const fsm_dynamo_1 = require("@futdevpro/fsm-dynamo");
 /**
- * `FAM_Console_Util` (FEAT-001) — `fam start`-kor (a PRIMARY példánynál) megnyit egy KÜLÖN, vizuálisan
- * látható terminál-ablakot, ami a szerver folyó tevékenységét mutatja.
+ * `FAM_Console_Util` — a leválasztott (detached) FAM REST-szerver indítása a SAJÁT, LÁTHATÓ konzol-ablakában.
  *
- * **Miért nem a process saját konzolja?** MCP-stdio módban a process stdout-ja a JSON-RPC csatorna —
- * azt NEM szabad konzol-ablakká tenni. Ezért a látható ablak egy KÜLÖN monitor-process, ami a szerver
- * **activity-logját tail-eli**: a `tee`-vel a `console.*` kimenetet egy log-fájlba is írjuk (a meglévő
- * stderr/stdout mellé), és egy platform-natív terminál-ablakot indítunk, ami azt a fájlt követi.
+ * **A szerver MAGA fut egy látható terminál-ablakban** (user-direktíva 2026-06-22: „a FAM-szervernek MINDIG
+ * saját látható ablakban kell megnyílnia"): a `spawnServerWindow` egy platform-natív terminál-ablakot nyit, ami
+ * KÖZVETLENÜL a `node`-ot futtatja → az ablak a szerver élő stdout/stderr-jét mutatja. Az ablak `detached` +
+ * `unref()` → TELJESEN FÜGGETLEN a hívótól (CLI / agent / subagent): amikor a hívó végez, az ablak NEM záródik be.
  *
- * **Default ON.** Kikapcsolható: `FAM_SHOW_CONSOLE=false|0|off|no` (a docker-compose ezt állítja, mert
- * a konténerben nincs GUI). Minden lépés **fail-safe** (try/catch) — az ablak hibája SOHA nem töri a bootot.
+ * **Nincs „activity-monitor" ablak.** A régi FEAT-001 tail-monitor (log-fájlt tail-elő külön ablak) **VÉGLEG
+ * ELTÁVOLÍTVA** (user-direktíva 2026-06-22: „a monitor-ablakot soha többé sehol; minden kapcsolódó kódot törölj").
+ * Egy szerver = EGY ablak (a szerver konzolja), semmi más.
  *
- * **Részletesség (`isVerbose`, `FAM_CONSOLE_VERBOSE`):** default VERBOSE → MINDEN `console.*` log-sor a
- * monitorba kerül (user-direktíva). `FAM_CONSOLE_VERBOSE=false` → kurált allowlist (`isActivityRelevant`).
+ * **File-log (`installFileLog`):** opcionálisan a `console.*` kimenet egy fájlba is rácsatolható (`FAM_LOG_FILE`),
+ * hogy a logok a látható ablak MELLETT fájlból is tail-elhetők legyenek (a `fam serve` ezt állítja be a detached szerverre).
  */
 class FAM_Console_Util {
     /**
-     * A monitor-lock **frissesség-küszöbe** (ms): ha a lockfile mtime-ja ennél régebbi, a monitor-ablakot
-     * HALOTTNAK tekintjük (bezárták) → új nyitható. A nyitott ablak `MONITOR_HEARTBEAT_MS`-enként frissíti a
-     * lockot (a PID-alapú check helyett — az törékeny: async PID-write-race a `start`-detach miatt + Windows
-     * PID-reuse → FELESLEGES dupla ablakok szerver-restartkor; a frissesség mindkettőt megoldja).
-     */
-    static MONITOR_STALE_MS = 10_000;
-    /** A monitor-ablak heartbeat-periódusa (ms): ennyente frissíti a lockfile mtime-ját, amíg él. */
-    static MONITOR_HEARTBEAT_MS = 3_000;
-    /**
-     * Az activity-monitor-ablak engedélyezett-e. **Default OFF** (opt-in) — user-direktíva 2026-06-21: a külön
-     * FEAT-001 tail-monitort kivettük, mert a `fam serve` saját LÁTHATÓ konzol-ablakot ad (az a szerver-aktivitás),
-     * így a külön monitor redundáns. Csak EXPLICIT `FAM_SHOW_CONSOLE=true|1|on|yes` esetén nyílik (ritka:
-     * pl. ha valaki a stdio-MCP `fam start`-ot primary-ként futtatja és mégis tail-ablakot szeretne).
-     */
-    static isEnabled() {
-        const raw = (process.env.FAM_SHOW_CONSOLE ?? '').trim().toLowerCase();
-        return raw === 'true' || raw === '1' || raw === 'on' || raw === 'yes';
-    }
-    /**
-     * Az activity-LOG **verbose**-e (`FAM_CONSOLE_VERBOSE`). **Default ON** (user-direktíva: a monitor MINDEN
-     * log-sort írjon ki) → a `console.*` minden nem-üres sora a monitor-ablakba kerül. `false|0|off|no` → a
-     * **kurált** allowlist (csak `[fam…]` + mongo-connect + hiba/figyelmeztetés; a boot-zaj kimarad). A kettő
-     * trade-off: VERBOSE = teljes átláthatóság (de zajosabb), kurált = csak a lényeg.
-     */
-    static isVerbose() {
-        const raw = (process.env.FAM_CONSOLE_VERBOSE ?? '').trim().toLowerCase();
-        return raw !== 'false' && raw !== '0' && raw !== 'off' && raw !== 'no';
-    }
-    /**
-     * **File-log (`FAM_LOG_FILE`)** — ha az env be van állítva, a `console.*` MINDEN sorát (SZŰRETLEN) rácsatolja
-     * arra a fájlra, FÜGGETLENÜL a monitor-ablaktól (`FAM_SHOW_CONSOLE`). A `fam serve` ezt állítja be a detached
-     * szerverre → a szerver logjai (köztük az import-progress) **FÁJLBÓL OLVASHATÓK** (tail-elhetők), nem csak a
-     * GUI-ablakból. Append-mód (boot-szeparátorral), fail-safe (a log-write SOHA nem dönti meg a szervert).
+     * **File-log (`FAM_LOG_FILE`)** — ha az env be van állítva, a `console.*` MINDEN sorát rácsatolja arra a fájlra
+     * (a látható ablak MELLETT). A `fam serve` ezt állítja a detached szerverre → a logok (köztük az import-progress)
+     * fájlból is OLVASHATÓK/tail-elhetők. Append-mód (boot-szeparátorral), fail-safe (a log-write SOHA nem dönti meg a szervert).
      */
     static installFileLog() {
         const logPath = (process.env.FAM_LOG_FILE ?? '').trim();
@@ -100,223 +70,19 @@ class FAM_Console_Util {
         console.error = wrap(console.error);
     }
     /**
-     * A PRIMARY szerver activity-konzol-ablakának megnyitása: log-fájl-tee + platform-natív monitor-ablak.
-     * Disabled (`FAM_SHOW_CONSOLE` off) vagy bármilyen hiba esetén CSENDES no-op (a boot folytatódik).
-     */
-    static openActivityConsole(set) {
-        if (!FAM_Console_Util.isEnabled()) {
-            return;
-        }
-        try {
-            const logPath = path.join(os.tmpdir(), `fam-activity-${set.port}.log`);
-            const lockPath = path.join(os.tmpdir(), `fam-activity-${set.port}.lock`);
-            // A log-fájl PERSISTÁL a (reconnect miatti) szerver-újraindulások között: header CSAK ha új,
-            // különben separator. A folyó monitor-ablak UGYANAZT a fájlt tail-eli, így a tevékenység
-            // akkumulálódik (nem csonkol minden bootkor — ez okozta a „nincs érdemi info"-t).
-            const mode = FAM_Console_Util.isVerbose() ? 'VERBOSE (minden log)' : 'kurált (allowlist)';
-            if (!fs.existsSync(logPath)) {
-                fs.writeFileSync(logPath, `# FAM activity log — port ${set.port} — ${new Date().toISOString()} — mód: ${mode}\n`);
-            }
-            else {
-                fs.appendFileSync(logPath, `# --- szerver-process (újra)indult — ${new Date().toISOString()} — mód: ${mode} ---\n`);
-            }
-            FAM_Console_Util.teeConsoleToFile(logPath);
-            // EGYETLEN monitor-ablak: ha már fut egy (a lockfile-beli PID él), NEM nyitunk újat — csak tee-zünk
-            // a közös logba (ezt mutatja a meglévő ablak). Így a reconnect-churn NEM spamel új terminálokat.
-            if (FAM_Console_Util.isMonitorAlive(lockPath)) {
-                return;
-            }
-            FAM_Console_Util.spawnMonitorWindow(logPath, lockPath, set.port);
-        }
-        catch (error) {
-            fsm_dynamo_1.DyFM_Log.warn(`[FAM console] activity-ablak megnyitása sikertelen (a szerver fut tovább): ${error?.message}`);
-        }
-    }
-    /**
-     * Fut-e már egy ÉLŐ monitor-ablak ehhez a porthoz? **Frissesség-alapú** (a régi PID-check helyett): a nyitott
-     * ablak `MONITOR_HEARTBEAT_MS`-enként frissíti a lockfile-t (mtime), így ha az mtime `MONITOR_STALE_MS`-nél
-     * frissebb → él (reuse, NEM nyitunk újat); ha régebbi → az ablakot bezárták → új nyitható. Ez immun a Windows
-     * `start`-detach okozta async PID-write-race-re ÉS a PID-reuse-ra (a két ok, ami szerver-restartkor dupla
-     * ablakot nyitott). Hiányzó/olvashatatlan lock → nincs élő ablak.
-     */
-    static isMonitorAlive(lockPath) {
-        try {
-            if (!fs.existsSync(lockPath)) {
-                return false;
-            }
-            const ageMs = Date.now() - fs.statSync(lockPath).mtimeMs;
-            return ageMs < FAM_Console_Util.MONITOR_STALE_MS;
-        }
-        catch {
-            return false;
-        }
-    }
-    /** A `console.*` kimenet rácsatolása a log-fájlra (a meglévő stderr/stdout MELLÉ — nem helyette). */
-    static teeConsoleToFile(logPath) {
-        const append = (line) => {
-            try {
-                fs.appendFileSync(logPath, `${line}\n`);
-            }
-            catch {
-                /* a fájl-append hibája soha nem dönti meg a szervert */
-            }
-        };
-        const stringify = (value) => {
-            if (typeof value === 'string') {
-                return value;
-            }
-            try {
-                return JSON.stringify(value);
-            }
-            catch {
-                return String(value);
-            }
-        };
-        const wrap = (original) => {
-            return (...args) => {
-                original(...args);
-                // A stderr/stdout a TELJES kimenetet kapja (változatlan); az activity-LOGba viszont CSAK a
-                // tevékenység-releváns sorok kerülnek — a boot-banner (ASCII-art, endpoint-mount, mongoose-
-                // warning) így nem szemeteli az ablakot, és a [fam*] activity nem süllyed el (a user-panasz).
-                const line = args.map(stringify).join(' ');
-                if (FAM_Console_Util.isActivityRelevant(line)) {
-                    append(line);
-                }
-            };
-        };
-        console.log = wrap(console.log.bind(console));
-        console.info = wrap(console.info.bind(console));
-        console.warn = wrap(console.warn.bind(console));
-        console.error = wrap(console.error.bind(console));
-        console.debug = wrap(console.debug.bind(console));
-    }
-    /**
-     * Activity-releváns-e egy log-sor → bekerül-e a monitor-ablakba. **VERBOSE módban** (default, `isVerbose`)
-     * MINDEN nem-üres sor átmegy (a user „minden logot" direktívája). **Kurált módban** (`FAM_CONSOLE_VERBOSE=
-     * false`) allowlist: minden `[fam…]`/`[FAM …]` sor (famRead/famWrite/famIngest + `[FAM hydrate]`/`[FAM MCP]`
-     * boot-státusz), a `Connected to MongoDB`, a `…successfully`, és MINDEN hiba/figyelmeztetés (hogy a problémák
-     * SOHA ne tűnjenek el); minden más (a teljes Express/Dynamo boot-banner) kimarad (stderr-en marad).
-     */
-    static isActivityRelevant(line) {
-        const trimmed = line.trim();
-        if (!trimmed) {
-            return false;
-        }
-        // VERBOSE (default): minden nem-üres sor a monitorba — teljes átláthatóság (user-direktíva).
-        if (FAM_Console_Util.isVerbose()) {
-            return true;
-        }
-        if (/^\[fam/i.test(trimmed)) {
-            return true;
-        }
-        if (/connected to mongodb|successfully/i.test(trimmed)) {
-            return true;
-        }
-        return /\b(error|warn|warning|fail|failed|exception|critical)\b/i.test(trimmed);
-    }
-    /**
-     * Platform-natív terminál-ablak indítása, ami a log-fájlt tail-eli (detached, fail-safe). Az ablak
-     * `MONITOR_HEARTBEAT_MS`-enként **frissíti a lockot** (heartbeat), így a következő (reconnect/restart miatti)
-     * boot az mtime-frissességből látja, hogy él → NEM nyit újat (`isMonitorAlive`). A spawn ELŐTT egy
-     * provisional friss lockot is írunk (a közel-egyidejű boot-race ellen).
-     */
-    static spawnMonitorWindow(logPath, lockPath, port) {
-        try {
-            FAM_Console_Util.touchLock(lockPath); // provisional friss mtime — a spawn alatti race-dupla ellen
-            if (process.platform === 'win32') {
-                // A monitor-logikát egy temp `.ps1`-be írjuk + `-File`-lal futtatjuk → NINCS `-Command`-escaping-
-                // rémálom (a sok `()[]{}|::`). A script HEARTBEAT-eli a lockot (a régi async `$PID`-write helyett —
-                // az okozta a PID-race/reuse dupla-ablakokat), és StreamReader-rel STREAMING-tail-el (UTF-8, a
-                // `Get-Content -Wait` helyett, hogy a heartbeat a [fam*]-zaj alatt is frissen tartsa a lockot).
-                const scriptPath = path.join(os.tmpdir(), `fam-activity-monitor-${port}.ps1`);
-                fs.writeFileSync(scriptPath, FAM_Console_Util.windowsMonitorScript(logPath, lockPath, port));
-                const child = (0, child_process_1.spawn)(process.env.ComSpec ?? 'cmd.exe', ['/c', 'start', '', 'powershell', '-NoExit', '-ExecutionPolicy', 'Bypass', '-File', scriptPath], { detached: true, stdio: 'ignore', windowsHide: false });
-                child.unref();
-                return;
-            }
-            // mac/linux: a tail MELLETT egy heartbeat-loop (a lockot frissíti, amíg a tail — így az ablak — él);
-            // a `kill -0 $tailPid` figyeli a tail-t, így az ablak bezárásakor a loop is kilép (nincs árva heartbeat).
-            const heartbeatSec = Math.max(1, Math.round(FAM_Console_Util.MONITOR_HEARTBEAT_MS / 1000));
-            const shellCmd = `tail -n 200 -f '${logPath}' & tp=$!; `
-                + `while kill -0 $tp 2>/dev/null; do : > '${lockPath}'; sleep ${heartbeatSec}; done`;
-            if (process.platform === 'darwin') {
-                const script = `tell application "Terminal" to do script "${shellCmd.replace(/"/g, '\\"')}"`;
-                const child = (0, child_process_1.spawn)('osascript', ['-e', script], { detached: true, stdio: 'ignore' });
-                child.unref();
-                return;
-            }
-            const terminal = FAM_Console_Util.findLinuxTerminal();
-            if (!terminal) {
-                fsm_dynamo_1.DyFM_Log.warn('[FAM console] nincs ismert Linux terminál-emulátor — az activity-ablak kihagyva '
-                    + `(a log a fájlban: ${logPath}; tail-eld kézzel, vagy FAM_SHOW_CONSOLE=false).`);
-                return;
-            }
-            const child = (0, child_process_1.spawn)(terminal, ['-e', 'sh', '-c', shellCmd], { detached: true, stdio: 'ignore' });
-            child.unref();
-        }
-        catch (error) {
-            fsm_dynamo_1.DyFM_Log.warn(`[FAM console] a monitor-ablak indítása sikertelen: ${error?.message}`);
-        }
-    }
-    /**
-     * A Windows monitor-`.ps1` tartalma: UTF-8 streaming-tail (StreamReader; a `Get-Content -Wait` helyett, hogy
-     * a heartbeat akkor is frissüljön, ha sok a log-sor) + `MONITOR_HEARTBEAT_MS`-enkénti lock-frissítés (a
-     * heartbeat). Az ablak bezárásakor a PowerShell-process megszűnik → a lock mtime elöregszik → `isMonitorAlive`
-     * false → a következő boot új ablakot nyit (helyesen). A path-okban a `'`-eket megdupláljuk (PS escape, defenzív).
-     */
-    static windowsMonitorScript(logPath, lockPath, port) {
-        const log = logPath.replace(/'/g, "''");
-        const lock = lockPath.replace(/'/g, "''");
-        return [
-            'try { [Console]::OutputEncoding=[System.Text.Encoding]::UTF8 } catch {}',
-            `try { $host.UI.RawUI.WindowTitle='FAM activity (${port})' } catch {}`,
-            `$log='${log}'`,
-            `$lock='${lock}'`,
-            'if (Test-Path -LiteralPath $log) { Get-Content -LiteralPath $log -Tail 200 -Encoding UTF8 | Write-Host }',
-            "$fs=[System.IO.File]::Open($log,'Open','Read','ReadWrite')",
-            '$sr=New-Object System.IO.StreamReader($fs,[System.Text.Encoding]::UTF8)',
-            '$sr.BaseStream.Seek(0,[System.IO.SeekOrigin]::End) | Out-Null',
-            '$beat=0',
-            'while ($true) {',
-            '  $line=$sr.ReadLine()',
-            '  if ($null -ne $line) { Write-Host $line } else { Start-Sleep -Milliseconds 400 }',
-            '  $now=[DateTimeOffset]::Now.ToUnixTimeMilliseconds()',
-            `  if (($now - $beat) -ge ${FAM_Console_Util.MONITOR_HEARTBEAT_MS}) { [System.IO.File]::WriteAllText($lock,[string]$now); $beat=$now }`,
-            '}',
-        ].join('\r\n');
-    }
-    /** A lockfile mtime-jának frissítése (a monitor „élő" jelzése, heartbeat). Fail-safe. */
-    static touchLock(lockPath) {
-        try {
-            fs.writeFileSync(lockPath, String(Date.now()));
-        }
-        catch {
-            /* a lock-write hibája soha nem dönti meg a szervert */
-        }
-    }
-    /** Az első elérhető Linux terminál-emulátor (PATH-on), vagy null. */
-    static findLinuxTerminal() {
-        const candidates = ['x-terminal-emulator', 'gnome-terminal', 'konsole', 'xfce4-terminal', 'xterm'];
-        for (const candidate of candidates) {
-            for (const dir of (process.env.PATH ?? '').split(path.delimiter)) {
-                if (dir && fs.existsSync(path.join(dir, candidate))) {
-                    return candidate;
-                }
-            }
-        }
-        return null;
-    }
-    /**
-     * Egy VISIBLE, OLVASHATÓ terminál-ablak nyitása, amiben a megadott parancs (a FAM REST-szerver) FUT. A
-     * `fam serve` (FEAT-003) ezt használja: a `start`/terminál TELJESEN LEVÁLASZTJA a szervert a hívóról (saját
-     * konzol-ablak), így túléli a CLI-t, és az ablak a szerver **élő stdout/stderr-jét** mutatja közvetlenül.
-     * Ezért a szervert `FAM_SHOW_CONSOLE=false`-szal indítjuk (a serve env-override-ja) — a FEAT-001 külön
-     * tail-monitor-ablak ehhez **redundáns** (nem nyílik 2. ablak). Fail-safe (a hívó `--foreground`-ra eshet vissza).
+     * A FAM REST-szerver indítása EGY LÁTHATÓ, DETACHED terminál-ablakban, ami KÖZVETLENÜL a `node`-ot futtatja
+     * (az ablak a szerver konzolja). A `start`/terminál TELJESEN LEVÁLASZTJA a szervert a hívóról → **túléli a
+     * hívó (CLI / agent / subagent) kilépését** (amikor a hívó végez, az ablak NEM záródik be). Az ablak a kilépés
+     * UTÁN is nyitva marad (`-NoExit` / `exec $SHELL`), hogy a boot-hiba látható maradjon. Fail-safe (`--foreground`
+     * fallback, ha nincs terminál).
+     *
+     * `command` = `process.execPath` (node), `args` = `[--max-old-space-size=…, build/src/index.js]`. Az env-override-ok
+     * a futtató shellbe kerülnek (PS `$env:` / POSIX `export`).
      */
     static spawnServerWindow(set) {
         if (process.platform === 'win32') {
-            // Launcher-`.ps1` (mint a FEAT-001 monitor) → NINCS `-Command`-escaping-rémálom; `-NoExit` → az ablak
-            // a szerver kilépése (vagy crash) UTÁN is nyitva marad (a hiba látható).
+            // Launcher-`.ps1` → NINCS `-Command`-escaping-rémálom; `-NoExit` → az ablak a szerver kilépése/crash UTÁN is
+            // nyitva marad. A `cmd /c start` ÚJ, látható ablakot nyit; a `detached`+`unref` leválasztja a hívóról (túléli).
             const scriptPath = path.join(os.tmpdir(), `fam-server-${set.port}.ps1`);
             fs.writeFileSync(scriptPath, FAM_Console_Util.windowsServerScript(set));
             const child = (0, child_process_1.spawn)(process.env.ComSpec ?? 'cmd.exe', ['/c', 'start', '', 'powershell', '-NoExit', '-ExecutionPolicy', 'Bypass', '-File', scriptPath], { detached: true, stdio: 'ignore', windowsHide: false });
@@ -344,9 +110,9 @@ class FAM_Console_Util {
         child.unref();
     }
     /**
-     * A Windows szerver-launcher `.ps1` tartalma: UTF-8 konzol + ablakcím, az env-override-ok (`$env:X='...'`),
-     * majd a szerver futtatása (`& command args`). A `'`-eket megdupláljuk (PS string-escape). A `-NoExit`
-     * (a spawn-oldalon) tartja nyitva az ablakot kilépés után.
+     * A Windows szerver-launcher `.ps1` tartalma (PURE — unit-tesztelhető): UTF-8 konzol + ablakcím, az env-override-ok
+     * (`$env:X='...'`), majd a szerver futtatása (`& command args`). A `'`-eket megdupláljuk (PS string-escape). A
+     * `-NoExit` (a spawn-oldalon) tartja nyitva az ablakot kilépés után.
      */
     static windowsServerScript(set) {
         const esc = (value) => value.replace(/'/g, "''");
@@ -363,5 +129,17 @@ class FAM_Console_Util {
         lines.push("Write-Host \"[FAM szerver kilépett — exit $LASTEXITCODE — 'fam serve --restart' újraindítja]\"");
         return lines.join('\r\n');
     }
+    /** Az első elérhető Linux terminál-emulátor (PATH-on), vagy null. */
+    static findLinuxTerminal() {
+        const candidates = ['x-terminal-emulator', 'gnome-terminal', 'konsole', 'xfce4-terminal', 'xterm'];
+        for (const candidate of candidates) {
+            for (const dir of (process.env.PATH ?? '').split(path.delimiter)) {
+                if (dir && fs.existsSync(path.join(dir, candidate))) {
+                    return candidate;
+                }
+            }
+        }
+        return null;
+    }
 }
 exports.FAM_Console_Util = FAM_Console_Util;

package/build/src/_collections/fam-db-models.const.js

@@ -11,6 +11,7 @@ const fam_knowledge_data_model_1 = require("../_models/data-models/fam-knowledge
 const fam_memory_data_model_1 = require("../_models/data-models/fam-memory.data-model");
 const fam_reference_data_model_1 = require("../_models/data-models/fam-reference.data-model");
 const fam_rules_data_model_1 = require("../_models/data-models/fam-rules.data-model");
+const fam_scan_job_data_model_1 = require("../_models/data-models/fam-scan-job.data-model");
 const fam_scope_data_model_1 = require("../_models/data-models/fam-scope.data-model");
 /**
  * A FAM perzisztens collection-jeinek `dataParams`-listája (MP-1, dsgn-001) — **SSOT**.
@@ -32,6 +33,7 @@ exports.FAM_DB_MODELS = [
     fam_reference_data_model_1.famReference_dataParams, // fam_reference
     fam_scope_data_model_1.famScope_dataParams, // fam_scopes
     fam_ingest_run_data_model_1.famIngestRun_dataParams, // fam_ingest_runs
+    fam_scan_job_data_model_1.famScanJob_dataParams, // fam_scan_jobs (FEAT-008 Phase 4 — durable scan-job + auto-resume)
     // Config-réteg (MP-7, dsgn-007): DB-backed scoped config (global<table<scope).
     fam_config_data_model_1.famConfig_dataParams, // fam_config
 ];