@futdevpro/fdp-agent-memory 1.1.21 → 1.1.112

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
 ];

package/build/src/_collections/fam-entry-bootstrap.util.js

@@ -9,6 +9,7 @@ const app_server_1 = require("../app.server");
 const package_json_1 = require("../../package.json");
 const mcp_1 = require("../_modules/mcp");
 const fam_client_service_1 = require("../_cli/_services/fam-client.service");
+const serve_command_1 = require("../_cli/_commands/serve.command");
 const register_commands_1 = require("../_cli/register-commands");
 const fam_console_util_1 = require("./fam-console.util");
 const fam_mcp_bridge_util_1 = require("./fam-mcp-bridge.util");
@@ -92,6 +93,23 @@ class FAM_EntryBootstrap_Util {
             fsm_dynamo_1.DyFM_Log.warn(`[FAM] már fut egy egészséges FAM-primary (${client.getBaseUrl()}${versionTag}) — a második REST-boot kihagyva.${versionNote}`);
             return;
         }
+        if (isStart && !serverAlreadyRunning) {
+            // AUTO-ENSURE (user-FR 2026-06-22: „minden fam funkciónak gondoskodnia kell a fam elindításáról"). Az MCP-
+            // stdio process NE a heavy REST-primary-t bootolja IN-PROCESS (az OOM-nál MEGHAL → a Claude-reconnect crash-
+            // loop-ol), hanem húzzon fel egy LEVÁLASZTOTT primary-t (túléli a reconnectet) és BRIDGE-eljen hozzá. A
+            // `waitMs:1` csak a spawn-t INDÍTJA (nem várja a teljes pool-bootot) → az MCP-handshake (ListTools, ami nem
+            // igényli a primary-t) AZONNAL kész; a tool-CALL-ok a bridge-önhealen várnak/retry-znek a boot-ra.
+            const ensured = await serve_command_1.FAM_Serve_Util.ensureRunning({ waitMs: 1 });
+            const spawnUnavailable = ensured.reason === 'no-entry' || ensured.reason === 'spawn-failed' || ensured.reason === 'remote-unreachable';
+            if (!spawnUnavailable) {
+                fsm_dynamo_1.DyFM_Log.info(`[FAM] auto-ensure: leválasztott primary (${ensured.reason}, ${ensured.url}) → MCP-stdio BRIDGE `
+                    + '(a primary a háttérben bootol; a tool-hívások önhealnek).');
+                await fam_mcp_bridge_util_1.FAM_McpBridge_Util.start({ name: MCP_SERVER_NAME, version: package_json_1.version });
+                return;
+            }
+            // A leválasztott spawn nem indítható (nincs belépő / spawn-hiba / remote-URL) → VISSZA a bevált in-process PRIMARY-ra.
+            fsm_dynamo_1.DyFM_Log.warn(`[FAM] auto-ensure: a leválasztott primary nem indítható (${ensured.reason}) → in-process PRIMARY boot (fallback).`);
+        }
         // PRIMARY-jelölt (nincs egészséges futó primary). Port pre-flight: ha a portot MÁS tartja (egy nem-FAM
         // process, VAGY egy fél-halott FAM-szerver, ami már nem válaszol a `/api/health`-en), a kötés EADDRINUSE-
         // szal bukna egy nyers stack-kel. Ehelyett TISZTA, akcióképes hibát adunk és kilépünk (nem crashelünk).
@@ -105,14 +123,10 @@ class FAM_EntryBootstrap_Util {
         }
         // PRIMARY (nincs futó szerver, a port szabad) — a teljes szerver felhúzása.
         fsm_dynamo_1.DyFM_Log.info(`[FAM] PRIMARY mód: nincs futó FAM-primary → teljes szerver felhúzása (REST :${SERVER_PORT}`
-            + `${isStart ? ' + MCP stdio' : ''}). Activity-monitor: ${fam_console_util_1.FAM_Console_Util.isEnabled() ? 'ON' : 'OFF'}`
-            + `${fam_console_util_1.FAM_Console_Util.isEnabled() ? ` (${fam_console_util_1.FAM_Console_Util.isVerbose() ? 'VERBOSE — minden log' : 'kurált'})` : ''}.`);
+            + `${isStart ? ' + MCP stdio' : ''}).`);
         // File-log (FAM_LOG_FILE): a `fam serve` ezt állítja be → a detached szerver logjai (köztük az
-        // import-progress) FÁJLBÓL OLVASHATÓK (tail), a monitor-ablak nélkül is. Fail-safe, env-gated.
+        // import-progress) FÁJLBÓL OLVASHATÓK (tail) a látható szerver-ablak MELLETT. Fail-safe, env-gated.
         fam_console_util_1.FAM_Console_Util.installFileLog();
-        // (FEAT-001) A PRIMARY egy KÜLÖN, látható activity-konzol-ablakot nyit (env-gated, fail-safe,
-        // docker-ben OFF). Az MCP-stdio JSON-RPC csatornát NEM érinti (külön monitor-process tail-el).
-        fam_console_util_1.FAM_Console_Util.openActivityConsole({ port: SERVER_PORT });
         // (1) REST szerver felhúzása (a DyNTS_App ctor indítja a connect + setup + postProcess láncot;
         // a DyNTS_App a side-effect-konstruktor mintát követi — az `index.ts` is így indít).
         FAM_EntryBootstrap_Util.startRestApp();

package/build/src/_collections/fam-error-context.util.js

@@ -37,6 +37,7 @@ class FAM_ErrorContext_Util {
         FAM_ErrorContext_Util.setNumber(snapshot, 'chunkIndex', input.chunkIndex);
         FAM_ErrorContext_Util.setString(snapshot, 'query', input.query);
         FAM_ErrorContext_Util.setString(snapshot, 'provider', input.provider);
+        FAM_ErrorContext_Util.setString(snapshot, 'failedSample', input.failedSample);
         // Ha minden mező hiányzott, NINCS snapshot (a rekordon nem jelenik meg üres objektum).
         return Object.keys(snapshot).length ? snapshot : undefined;
     }

package/build/src/_collections/fam-mcp-bridge.util.js

@@ -4,6 +4,7 @@ exports.FAM_McpBridge_Util = void 0;
 const fam_core_tools_const_1 = require("../_modules/mcp/_collections/fam-core-tools.const");
 const fam_mcp_adapter_service_1 = require("../_modules/mcp/_services/fam-mcp-adapter.service");
 const fam_client_service_1 = require("../_cli/_services/fam-client.service");
+const serve_command_1 = require("../_cli/_commands/serve.command");
 /**
  * `FAM_McpBridge_Util` (FEAT-002, topology „egy szerver, sok bridge") — ha `fam start`-kor MÁR fut egy
  * FAM-szerver (primary, REST a 39265-ön), az új process NEM bootol második szervert (port-ütközés +
@@ -31,7 +32,20 @@ class FAM_McpBridge_Util {
                 description: tool.description,
                 inputSchema: tool.inputSchema,
                 handler: async (args) => {
-                    const result = await client.post(`/api/${tool.name}`, args ?? {});
+                    let result = await client.post(`/api/${tool.name}`, args ?? {});
+                    // ÖNHEAL (user-FR 2026-06-22): ha a primary időközben leesett (`unreachable`), NE bukjunk némán —
+                    // automatikusan felhúzzuk a leválasztott primary-t (`ensureRunning`) és EGYSZER újrapróbáljuk. Ha a
+                    // primary épp bootol (pool-hidratálás), tiszta „indul, próbáld újra" hibát adunk (a következő hívás megy).
+                    if (!result.ok && result.unreachable) {
+                        const ensured = await serve_command_1.FAM_Serve_Util.ensureRunning();
+                        if (ensured.running) {
+                            result = await client.post(`/api/${tool.name}`, args ?? {});
+                        }
+                        else if (ensured.reason === 'boot-timeout') {
+                            throw new Error('FAM-MCP-BRIDGE-002: A FAM primary most indul (pool-hidratálás folyamatban) — '
+                                + 'próbáld újra pár másodperc múlva. (Az auto-indítás már elindult, leválasztva.)');
+                        }
+                    }
                     if (!result.ok) {
                         // A primary hibáját MCP-hibaként felszínre hozzuk (NEM némítjuk; dsgn-008).
                         const code = result.error?.errorCode ?? 'FAM-MCP-BRIDGE-001';

package/build/src/_collections/fam-operation-queue.service.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FAM_OperationQueue_Service = void 0;
+/**
+ * `FAM_OperationQueue_Service` (FEAT-008, user-FR 2026-06-22) — **szerver-oldali soros/limitált-konkurrencia QUEUE**
+ * a NEHÉZ műveletekhez (scan/import/re-embed). A user-direktíva: a SZERVER vezérelje, hogy egyszerre NE fusson túl
+ * sok nehéz művelet — ha több agenttől egyidejű write-parancsok érkeznek, a szerver SORBA rakja (FIFO) és úgy
+ * dolgozza fel, NEM párhuzamosan. (Ez okozta a `war-factory`/`warbots` átfedést: a kliens-oldali orchestráció
+ * desync-elt — a kliens timeout-olt egy hosszú scant és elindította a következőt, miközben a szerver az elsőt még
+ * darálta. Ezzel a queue-val a 2. write MEGVÁRJA az elsőt → soros, átfedés-mentes feldolgozás a kliens-káosztól
+ * függetlenül.)
+ *
+ * Egyszerű async-szemafór: `maxConcurrency` default **1** (teljes szerializáció a nehéz ops-ra). A könnyű ops
+ * (create/update/delete/read) NEM mennek ezen át (gyorsak, nincs korrupciós kockázat). Statikus singleton —
+ * process-szintű (egy szerver = egy queue). Bukott task is felszabadít (finally) → nem akad meg a queue.
+ */
+class FAM_OperationQueue_Service {
+    /** A process-szintű singleton. */
+    static instance;
+    /** A singleton elérése (lazy). */
+    static getInstance() {
+        if (!FAM_OperationQueue_Service.instance) {
+            FAM_OperationQueue_Service.instance = new FAM_OperationQueue_Service();
+        }
+        return FAM_OperationQueue_Service.instance;
+    }
+    /** A konkurrencia-plafon (≥1). Default 1 = teljes szerializáció (egyszerre egy nehéz művelet). */
+    maxConcurrency = 1;
+    /** Hány task fut épp. */
+    running = 0;
+    /** A szabad slot-ra várók resolver-ei (FIFO sor). */
+    waiters = [];
+    /** A konkurrencia-plafon állítása (≥1). Növelésnél azonnal besorolja a várakozókat. */
+    setMaxConcurrency(value) {
+        this.maxConcurrency = Math.max(1, Math.floor(value));
+        this.drain();
+    }
+    /** Observability (a `/health`-be / progress-be köthető): hány fut + hány vár + a plafon. */
+    stats() {
+        return { running: this.running, queued: this.waiters.length, maxConcurrency: this.maxConcurrency };
+    }
+    /**
+     * A `task` BESOROLÁSA: megvárja a szabad slot-ot (FIFO), lefuttatja, majd felszabadít. A hiba is felszabadít
+     * (`finally`) — egy bukott task NEM akasztja meg a queue-t. A visszatérés a task eredménye (átlátszó wrapper).
+     */
+    async enqueue(task) {
+        await this.acquire();
+        try {
+            return await task();
+        }
+        finally {
+            this.release();
+        }
+    }
+    /** Slot-foglalás: ha van szabad → azonnal; különben FIFO-sorba (a resolver a `drain`-ben fut le). */
+    acquire() {
+        if (this.running < this.maxConcurrency) {
+            this.running++;
+            return Promise.resolve();
+        }
+        return new Promise((resolve) => {
+            this.waiters.push(resolve);
+        });
+    }
+    /** Slot-felszabadítás + a következő várakozó besorolása. */
+    release() {
+        this.running = Math.max(0, this.running - 1);
+        this.drain();
+    }
+    /** A szabad slot-okra besorol a várakozókból (FIFO), amíg van hely ÉS van várakozó. */
+    drain() {
+        while (this.running < this.maxConcurrency && this.waiters.length > 0) {
+            const next = this.waiters.shift();
+            if (next) {
+                this.running++;
+                next();
+            }
+        }
+    }
+    /** TESZT-only: a singleton eldobása (friss állapot a spec-ekhez). */
+    static resetForTest() {
+        FAM_OperationQueue_Service.instance = undefined;
+    }
+}
+exports.FAM_OperationQueue_Service = FAM_OperationQueue_Service;