@futdevpro/fdp-agent-memory 1.1.116 → 1.1.122

package/build/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@futdevpro/fdp-agent-memory",
-    "version": "1.1.116",
+    "version": "1.1.122",
     "description": "Local-first, vector-backed multi-table agent memory exposed as an MCP server (read/write/capabilities). Public, FDP-Templates-free, no auth.",
     "private": false,
     "publishConfig": {

package/build/src/_cli/_commands/remote.command.js

@@ -0,0 +1,141 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FAM_Remote_Util = void 0;
+const commander_1 = require("commander");
+const fam_remote_config_util_1 = require("../../_collections/fam-remote-config.util");
+const fam_output_util_1 = require("../_collections/fam-output.util");
+const fam_cli_const_1 = require("../_collections/fam-cli.const");
+const fam_client_service_1 = require("../_services/fam-client.service");
+/**
+ * `fam remote show|set|clear` — a TÁVOLI ELÉRÉS beállítása (user-FR 2026-07-28: „kéne építsünk a FAM-hoz beállítást,
+ * hogy távoli elérésként is működhessen — pl. virtuális gépről a host-ra kapcsolva, hogy a host futtat, de a VM is
+ * eléri, más címen/útvonalon").
+ *
+ * A beállítás a gép-lokális `~/.fam/config.json`-ben él (NEM a DB-config — az a szerveren van, amihez épp csatlakozni
+ * akarunk; és NEM új env-var — a hookok/MCP/CLI külön process-ek, egy fájl mindnek szól).
+ *
+ * **Tipikus VM→host setup:**
+ * - HOST-on: `fam remote set --bind 192.168.56.1` (a host-only adapter IP-je) + `fam serve --restart`
+ * - VM-ben:  `fam remote set --url http://192.168.56.1:39265` → a VM CLI/hook/MCP a hostot használja
+ * - Reverse proxy mögött: `fam remote set --url https://host.local/fam` (az útvonal-prefix támogatott)
+ */
+class FAM_Remote_Util {
+    /** A `remote` parancs-deszkriptor (show/set/clear alparanccsal). */
+    static command() {
+        const command = new commander_1.Command('remote');
+        command.description('Távoli elérés beállítása (~/.fam/config.json): kliens szerver-URL + szerver bind-host');
+        command.addCommand(FAM_Remote_Util.showCommand());
+        command.addCommand(FAM_Remote_Util.setCommand());
+        command.addCommand(FAM_Remote_Util.clearCommand());
+        return command;
+    }
+    /** `remote show` — az aktuális (feloldott) beállítás + a tényleges elérhetőség. */
+    static showCommand() {
+        const command = new commander_1.Command('show');
+        command
+            .description('A jelenlegi távoli-elérés beállítás + elérhetőség-próba')
+            .action(async () => {
+            fam_output_util_1.FAM_Output_Util.exit(await FAM_Remote_Util.runShow(command));
+        });
+        return command;
+    }
+    /** `remote set` — a szerver-URL és/vagy a bind-host beállítása. */
+    static setCommand() {
+        const command = new commander_1.Command('set');
+        command
+            .description('A kliens szerver-URL és/vagy a szerver bind-host beállítása')
+            .option('--url <url>', 'KLIENS: a FAM szerver base-URL-je (útvonal-prefix is lehet, pl. https://host/fam)')
+            .option('--bind <host>', 'SZERVER: bind-host (127.0.0.1 = csak lokális, 0.0.0.0 vagy "*" = minden interfész, '
+            + 'vagy egy konkrét adapter-IP). Csak a szerver ÚJRAINDÍTÁSA után lép életbe.')
+            .action(async () => {
+            fam_output_util_1.FAM_Output_Util.exit(await FAM_Remote_Util.runSet(command));
+        });
+        return command;
+    }
+    /** `remote clear` — a beállítások törlése (vissza a lokális default-ra). */
+    static clearCommand() {
+        const command = new commander_1.Command('clear');
+        command
+            .description('A távoli-elérés beállítások törlése (vissza a lokális default-ra)')
+            .action(async () => {
+            fam_output_util_1.FAM_Output_Util.exit(await FAM_Remote_Util.runClear(command));
+        });
+        return command;
+    }
+    /** A `remote show` futtatása: a feloldott értékek + honnan jönnek + elérhető-e a szerver. */
+    static async runShow(command) {
+        const globals = command.optsWithGlobals();
+        const file = fam_remote_config_util_1.FAM_RemoteConfig_Util.load();
+        const serverUrl = fam_remote_config_util_1.FAM_RemoteConfig_Util.resolveServerUrl({
+            override: globals.serverUrl, env: process.env.FAM_SERVER_URL, file: file,
+        });
+        const bindHost = fam_remote_config_util_1.FAM_RemoteConfig_Util.resolveBindHost({ env: process.env.FAM_SERVER_HOST, file: file });
+        const client = new fam_client_service_1.FAM_CliClient_Service(globals.serverUrl);
+        return fam_output_util_1.FAM_Output_Util.success({
+            options: globals,
+            command: 'remote show',
+            data: {
+                configPath: fam_remote_config_util_1.FAM_RemoteConfig_Util.CONFIG_PATH,
+                serverUrl: serverUrl,
+                serverUrlFrom: FAM_Remote_Util.describeSource(globals.serverUrl, process.env.FAM_SERVER_URL, file.serverUrl),
+                bindHost: bindHost,
+                bindHostFrom: FAM_Remote_Util.describeSource(undefined, process.env.FAM_SERVER_HOST, file.bindHost),
+                bindIsLoopbackOnly: fam_remote_config_util_1.FAM_RemoteConfig_Util.isLoopbackHost(bindHost),
+                reachable: await client.isReachable(),
+            },
+        });
+    }
+    /** A `remote set` futtatása. */
+    static async runSet(command) {
+        const globals = command.optsWithGlobals();
+        const local = command.opts();
+        if (!local.url && !local.bind) {
+            return fam_output_util_1.FAM_Output_Util.failure({
+                options: globals, command: 'remote set',
+                error: {
+                    errorCode: 'FAM-CLI-REMOTE-001',
+                    message: 'Adj meg legalább egyet: `--url` (kliens) vagy `--bind` (szerver).',
+                    fixHint: 'Pl. VM-ből a hostra: `fam remote set --url http://192.168.56.1:39265`; '
+                        + 'a hoston: `fam remote set --bind 192.168.56.1` + `fam serve --restart`.',
+                },
+                exitCode: fam_cli_const_1.FAM_CliExitCode.usageError,
+            });
+        }
+        const saved = fam_remote_config_util_1.FAM_RemoteConfig_Util.save({ serverUrl: local.url, bindHost: local.bind });
+        const notes = [];
+        if (local.bind) {
+            notes.push('A bind-host CSAK a szerver újraindítása után lép életbe: `fam serve --restart`.');
+            const effective = fam_remote_config_util_1.FAM_RemoteConfig_Util.resolveBindHost({ file: saved });
+            if (!fam_remote_config_util_1.FAM_RemoteConfig_Util.isLoopbackHost(effective)) {
+                notes.push('FIGYELEM: a FAM-nak NINCS authentikációja (ADR-004) — a nem-loopback bind a TELJES '
+                    + 'korpuszt elérhetővé teszi az adott hálózaton. Csak megbízható (host-only / VPN) hálón használd.');
+            }
+        }
+        return fam_output_util_1.FAM_Output_Util.success({
+            options: globals, command: 'remote set',
+            data: { configPath: fam_remote_config_util_1.FAM_RemoteConfig_Util.CONFIG_PATH, config: saved, notes: notes },
+        });
+    }
+    /** A `remote clear` futtatása. */
+    static async runClear(command) {
+        const globals = command.optsWithGlobals();
+        const saved = fam_remote_config_util_1.FAM_RemoteConfig_Util.save({ serverUrl: null, bindHost: null });
+        return fam_output_util_1.FAM_Output_Util.success({
+            options: globals, command: 'remote clear',
+            data: { configPath: fam_remote_config_util_1.FAM_RemoteConfig_Util.CONFIG_PATH, config: saved,
+                notes: ['Vissza a lokális default-ra (kliens: http://127.0.0.1:39265, bind: 127.0.0.1). '
+                        + 'A bind változás a szerver újraindításakor lép életbe.'] },
+        });
+    }
+    /** Melyik forrásból jött a feloldott érték (flag > env > fájl > default) — a `show` átláthatóságához (PURE). */
+    static describeSource(flag, env, file) {
+        if (flag?.trim()) {
+            return 'flag (--server-url)';
+        }
+        if (env?.trim()) {
+            return 'env';
+        }
+        return file?.trim() ? 'config-fájl (~/.fam/config.json)' : 'beépített default';
+    }
+}
+exports.FAM_Remote_Util = FAM_Remote_Util;

package/build/src/_cli/_services/fam-client.service.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FAM_CliClient_Service = void 0;
-const fam_cli_const_1 = require("../_collections/fam-cli.const");
+const fam_remote_config_util_1 = require("../../_collections/fam-remote-config.util");
 /**
  * `FAM_CliClient_Service` — a CLI → szerver elérési réteg (dsgn-010 §9). A `read`/`write`/`scan`/
  * `stats`/`errors`/`config`/`capabilities` parancsok ezen át hívják a futó szerver REST-felületét
@@ -25,8 +25,12 @@ class FAM_CliClient_Service {
      *        `FAM_SERVER_URL`, különben a `FAM_DEFAULT_SERVER_URL`.
      */
     constructor(serverUrlOverride) {
-        const raw = serverUrlOverride || process.env.FAM_SERVER_URL || fam_cli_const_1.FAM_DEFAULT_SERVER_URL;
-        this.baseUrl = raw.replace(/\/+$/, '');
+        // TÁVOLI ELÉRÉS (user-FR 2026-07-28): a `~/.fam/config.json` `serverUrl`-je is beleszól — így egy VM-ből a
+        // host-on futó FAM elérhető anélkül, hogy MINDEN hívóhoz (CLI/hook/MCP külön process!) env-et kellene fűzni.
+        // Precedencia: `--server-url` flag > `FAM_SERVER_URL` env > config-fájl > `http://127.0.0.1:39265`.
+        this.baseUrl = fam_remote_config_util_1.FAM_RemoteConfig_Util.resolveServerUrl({
+            override: serverUrlOverride, env: process.env.FAM_SERVER_URL, file: fam_remote_config_util_1.FAM_RemoteConfig_Util.load(),
+        });
     }
     /** A feloldott szerver base-URL (a fix-tippekhez / diaghoz). */
     getBaseUrl() {

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

@@ -17,6 +17,7 @@ const seed_command_1 = require("./_commands/seed.command");
 const import_command_1 = require("./_commands/import.command");
 const export_command_1 = require("./_commands/export.command");
 const capture_command_1 = require("./_commands/capture.command");
+const remote_command_1 = require("./_commands/remote.command");
 /**
  * Regisztrálja az összes FDP Agent Memory-specifikus CLI command-ot (dsgn-010 §2 `buildCli()`).
  *
@@ -52,6 +53,7 @@ function registerFAMCommands(program, version) {
         export_command_1.FAM_Export_Util.command(),
         capture_command_1.FAM_Capture_Util.command(),
         config_command_1.FAM_Config_Util.command(),
+        remote_command_1.FAM_Remote_Util.command(),
         stats_command_1.FAM_Stats_Util.command(),
         find_duplicates_command_1.FAM_FindDuplicates_Util.command(),
         errors_command_1.FAM_Errors_Util.command(),

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',
@@ -67,12 +71,36 @@ exports.CONFIG_CATALOG = {
     // --- 4.1. Read / retrieval limitek (fogyasztó: dsgn-005) ---
     'read.topK': {
         type: 'number', default: 5, min: 1, max: 200, integer: true, levels: ALL_LEVELS,
-        description: 'Alap visszaadott találat-szám (CCAP DEFAULT_TOP_K=5).',
+        // PER-TÁR default (user-FR 2026-07-28): „amikor rule-okat vagy más FONTOS dolgot keresünk, ott nagyobb max
+        // találattal kell dolgozni, hogy MINDEN fontos elem/szabály MINDIG belekerüljön". A `rules` a legkritikusabb
+        // (egy hard-rule kimaradása = rossz döntés), utána a kurált `coding_patterns` / `knowledge` / `memory`. A
+        // `documents`/`codebase` marad az 5-ös alapon (ott a nagy korpusz miatt a szűk top-N a helyes — a `depth:'deep'`
+        // (`read.deepTopK`) adja a mély feltárást).
+        defaultsByTable: {
+            [fam_table_type_enum_1.FAM_Table.rules]: 30,
+            [fam_table_type_enum_1.FAM_Table.codingPatterns]: 20,
+            [fam_table_type_enum_1.FAM_Table.knowledge]: 15,
+            [fam_table_type_enum_1.FAM_Table.memory]: 15,
+        },
+        description: 'Alap visszaadott találat-szám (CCAP DEFAULT_TOP_K=5). **Per-tár default** (user-FR 2026-07-28): '
+            + '`rules` 30 · `coding_patterns` 20 · `knowledge`/`memory` 15 — hogy a FONTOS elemek (kanonikus szabályok, '
+            + 'kurált minták/tanulságok) MIND beleférjenek, ne csak a top-5. A `documents`/`codebase` marad 5 (nagy '
+            + 'korpusz → szűk top-N; a mély feltárás a `depth:"deep"` / `read.deepTopK`). Bármely EXPLICIT beállítás '
+            + '(scope/table/global) felülírja a per-tár default-ot.',
     },
     'read.deepTopK': {
         type: 'number', default: 25, min: 1, max: 200, integer: true, levels: ALL_LEVELS,
+        // A mély feltárás a FONTOS tárakon még bőségesebb (a normál per-tár topK FÖLÖTT kell maradnia — user-FR 2026-07-28).
+        defaultsByTable: {
+            [fam_table_type_enum_1.FAM_Table.rules]: 60,
+            [fam_table_type_enum_1.FAM_Table.codingPatterns]: 40,
+            [fam_table_type_enum_1.FAM_Table.knowledge]: 35,
+            [fam_table_type_enum_1.FAM_Table.memory]: 35,
+        },
         description: 'A `depth:"deep"` (mély feltárás) read-mód találat-száma: ennyit ad vissza, ha a query NEM '
-            + 'ad explicit topK-t. Sokkal több chunk/kontextus egy-egy mély feltáráshoz (a query topK felülírja).',
+            + 'ad explicit topK-t. Sokkal több chunk/kontextus egy-egy mély feltáráshoz (a query topK felülírja). '
+            + '**Per-tár default:** `rules` 60 · `coding_patterns` 40 · `knowledge`/`memory` 35 — a fontos tárak mély '
+            + 'feltárása a normál per-tár topK FÖLÖTT maradjon.',
     },
     'read.maxResults': {
         type: 'number', default: 50, min: 1, max: 500, integer: true, levels: ALL_LEVELS,
@@ -80,6 +108,14 @@ exports.CONFIG_CATALOG = {
     },
     'read.maxTokens': {
         type: 'number', default: 4000, min: 256, max: 32000, integer: true, levels: ALL_LEVELS,
+        // A megemelt per-tár topK ÖNMAGÁBAN nem elég: a token-budget levágná a többletet (a 30 szabály ~15k char ≈
+        // 3,7k token → a 4000-es budget pont elvágná). A fontos tárakon ezért a budget is arányosan nő (user-FR 2026-07-28).
+        defaultsByTable: {
+            [fam_table_type_enum_1.FAM_Table.rules]: 12000,
+            [fam_table_type_enum_1.FAM_Table.codingPatterns]: 8000,
+            [fam_table_type_enum_1.FAM_Table.knowledge]: 8000,
+            [fam_table_type_enum_1.FAM_Table.memory]: 8000,
+        },
         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`).',

package/build/src/_collections/fam-remote-config.util.js

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FAM_RemoteConfig_Util = void 0;
+const fs_1 = require("fs");
+const os_1 = require("os");
+const path_1 = require("path");
+/**
+ * `FAM_RemoteConfig_Util` — a gép-lokális `~/.fam/config.json` olvasása/írása + a TÁVOLI ELÉRÉS feloldása
+ * (user-FR 2026-07-28: „kéne építsünk a FAM-hoz beállítást, hogy távoli elérésként is működhessen — pl. virtuális
+ * gépről a host-ra kapcsolva, hogy a host futtat, de a VM is eléri, más címen/útvonalon").
+ *
+ * **Miért fájl és nem (új) env-var?** Az env csak abban a process-fában él, ahol beállították — a CC-hookok, az MCP-
+ * adapter és a CLI KÜLÖN process-ek, így env-vel mindegyiket külön kéne felkonfigurálni (és a workspace-guardrail is
+ * tiltja az új env-kulcsok szaporítását). A fájl EGY helyen, perzisztensen, minden hívónak érvényes. A MEGLÉVŐ
+ * `FAM_SERVER_URL` env továbbra is működik és ERŐSEBB a fájlnál (ad-hoc felülírás).
+ *
+ * **Precedencia (kliens):** `--server-url` flag > `FAM_SERVER_URL` env > `~/.fam/config.json` > `http://127.0.0.1:39265`.
+ * **Precedencia (szerver bind):** `FAM_SERVER_HOST` env > `~/.fam/config.json` > `127.0.0.1`.
+ */
+class FAM_RemoteConfig_Util {
+    /** A gép-lokális config-fájl útja (`~/.fam/config.json`). */
+    static CONFIG_PATH = (0, path_1.join)((0, os_1.homedir)(), '.fam', 'config.json');
+    /** A kliens-default (változatlan visszafelé-kompatibilis érték). */
+    static DEFAULT_SERVER_URL = 'http://127.0.0.1:39265';
+    /**
+     * A szerver BIND-default: **loopback**. Biztonsági alapállás — a FAM-nak nincs authja (ADR-004), ezért
+     * alapból NEM hallgatózik a hálózaton; a távoli elérés EXPLICIT opt-in (`bindHost`).
+     */
+    static DEFAULT_BIND_HOST = '127.0.0.1';
+    /**
+     * A config-fájl beolvasása. Best-effort: hiányzó/olvashatatlan/érvénytelen JSON → üres objektum (a FAM
+     * default-okkal indul; egy elrontott fájl SOHA nem akadályozhatja meg a szerver indulását).
+     */
+    static load() {
+        try {
+            if (!(0, fs_1.existsSync)(FAM_RemoteConfig_Util.CONFIG_PATH)) {
+                return {};
+            }
+            const parsed = JSON.parse((0, fs_1.readFileSync)(FAM_RemoteConfig_Util.CONFIG_PATH, 'utf8'));
+            if (!parsed || typeof parsed !== 'object') {
+                return {};
+            }
+            const raw = parsed;
+            return {
+                serverUrl: typeof raw.serverUrl === 'string' && raw.serverUrl.trim() ? raw.serverUrl.trim() : undefined,
+                bindHost: typeof raw.bindHost === 'string' && raw.bindHost.trim() ? raw.bindHost.trim() : undefined,
+            };
+        }
+        catch {
+            return {};
+        }
+    }
+    /** A config-fájl MÓDOSÍTÁSA (merge a meglévővel; a mappát létrehozza). A `null` érték TÖRLI a kulcsot. */
+    static save(patch) {
+        const current = FAM_RemoteConfig_Util.load();
+        const next = { ...current };
+        if (patch.serverUrl !== undefined) {
+            next.serverUrl = patch.serverUrl === null ? undefined : patch.serverUrl.trim();
+        }
+        if (patch.bindHost !== undefined) {
+            next.bindHost = patch.bindHost === null ? undefined : patch.bindHost.trim();
+        }
+        (0, fs_1.mkdirSync)((0, path_1.dirname)(FAM_RemoteConfig_Util.CONFIG_PATH), { recursive: true });
+        (0, fs_1.writeFileSync)(FAM_RemoteConfig_Util.CONFIG_PATH, `${JSON.stringify(next, null, 4)}\n`, 'utf8');
+        return next;
+    }
+    /**
+     * A KLIENS szerver-URL feloldása (PURE, tesztelhető — a bemenetek explicitek).
+     * Precedencia: flag > env > fájl > default. A záró `/`-eket levágja (a hívó `${base}/api/...`-t fűz).
+     */
+    static resolveServerUrl(set) {
+        const raw = set.override?.trim()
+            || set.env?.trim()
+            || set.file?.serverUrl?.trim()
+            || FAM_RemoteConfig_Util.DEFAULT_SERVER_URL;
+        return raw.replace(/\/+$/, '');
+    }
+    /**
+     * A SZERVER bind-host feloldása (PURE). Precedencia: env > fájl > loopback-default.
+     * A `'*'` kényelmi alias a `0.0.0.0`-ra (minden interfész).
+     */
+    static resolveBindHost(set) {
+        const raw = set.env?.trim() || set.file?.bindHost?.trim() || FAM_RemoteConfig_Util.DEFAULT_BIND_HOST;
+        return raw === '*' ? '0.0.0.0' : raw;
+    }
+    /**
+     * Loopback-e a bind (PURE)? A nem-loopback bind FIGYELMEZTETÉST érdemel: a FAM auth NÉLKÜLI (ADR-004), így a
+     * hálózaton bárki írhatja/olvashatja a teljes korpuszt. Csak megbízható (host-only/VPN) hálón indokolt.
+     */
+    static isLoopbackHost(host) {
+        return host === '127.0.0.1' || host === 'localhost' || host === '::1';
+    }
+}
+exports.FAM_RemoteConfig_Util = FAM_RemoteConfig_Util;

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/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

@@ -31,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();
@@ -79,23 +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.
-            if (!embedding_1.FAM_VectorSearch_ControlService.getInstance().hydrationSummary().complete) {
+            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;
+            }
+            // 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 mid-scan sem indít újra minden restartkor; a heti freshness
-            // best-effort, nem exactly-once), MAJD indítjuk a scant.
+            // 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();
         }
@@ -113,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.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.log(`[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/build/src/_modules/mcp/_services/fam-read-tool.service.js

@@ -45,16 +45,33 @@ class FAM_ReadTool_Service {
         // Token-budget ÉRVÉNYESÍTÉS (FAM-REV 2026-06-22): a read-válasz INLINE marad (különben a nagy találat-tartalom
         // miatt a MCP-host FÁJLBA menti → extra olvasás-lépés). A `read.maxTokens` (default 4000) felett a hit-tartalom
         // levágódik + a túlcsorduló hit-ek elhagyva, `truncated:true`-val. A FAM mindig DIREKT adja vissza a találatokat.
-        FAM_ReadTool_Service.applyTokenBudget(response, await FAM_ReadTool_Service.resolveMaxTokens());
+        FAM_ReadTool_Service.applyTokenBudget(response, await FAM_ReadTool_Service.resolveMaxTokens(input));
         this.logReadActivity(input, response);
         return response;
     }
-    /** A `read.maxTokens` config feloldása (default/fallback 4000, min 256). */
-    static async resolveMaxTokens() {
+    /**
+     * A `read.maxTokens` config feloldása (default/fallback 4000, min 256) — a QUERY-K TÁRAIRA feloldva (user-FR
+     * 2026-07-28). A fontos tárak (`rules`/`coding_patterns`/`knowledge`/`memory`) per-tár budget-default-ot kapnak,
+     * hogy a megemelt per-tár `topK` ne essen áldozatul a szűk token-budgetnek. A budget KÖZÖS az egész válaszra, ezért
+     * multi-tár read-nél a LEGNAGYOBB érintett tár-budget nyer (a fontos tár igénye nem veszhet el egy „olcsóbb" tár
+     * mellett). Tár nélküli (all-table) read → a globális feloldás.
+     */
+    static async resolveMaxTokens(input) {
         try {
-            const resolved = await config_control_service_1.FAM_Config_ControlService.getInstance().resolve('read.maxTokens', {});
-            const value = typeof resolved.value === 'number' ? resolved.value : Number(resolved.value);
-            return Number.isFinite(value) && value >= 256 ? Math.floor(value) : 4000;
+            const config = config_control_service_1.FAM_Config_ControlService.getInstance();
+            const tables = Array.from(new Set((input.queries ?? []).flatMap((query) => query.tables ?? [])));
+            const contexts = tables.length
+                ? tables.map((table) => ({ table: table }))
+                : [{}];
+            const values = [];
+            for (const context of contexts) {
+                const resolved = await config.resolve('read.maxTokens', context);
+                const value = typeof resolved.value === 'number' ? resolved.value : Number(resolved.value);
+                if (Number.isFinite(value) && value >= 256) {
+                    values.push(Math.floor(value));
+                }
+            }
+            return values.length ? Math.max(...values) : 4000;
         }
         catch {
             return 4000;

package/build/src/_routes/server/config/config.control-service.js

@@ -98,7 +98,20 @@ class FAM_Config_ControlService {
         if (globalHit) {
             return this.toResolved(globalHit, 'global');
         }
-        // 4. builtin default (mindig van — dsgn-007 §3 / §10.3).
+        // 4. PER-TÁR builtin default (`defaultsByTable`, 2026-07-28): ahol egy tár természetes igénye eltér a
+        // globálistól (pl. a `rules` tárban MINDEN releváns szabálynak be kell férnie, nem csak a top-5-nek), ott a
+        // tár saját default-ja érvényesül — DB-írás/seed nélkül. A fenti EXPLICIT szintek (scope/table/global) győznek.
+        // A katalógus `satisfies`-a megőrzi a kulcs-literál típusokat (szigorú `FAM_ConfigKey` union), ezért a közös
+        // opcionális mezők eléréséhez tipizált NÉZET kell — `as` cast NÉLKÜL (az entry-k `satisfies`-olják az interfészt).
+        const entry = config_catalog_const_1.CONFIG_CATALOG[key];
+        const byTable = table ? entry.defaultsByTable?.[table] : undefined;
+        if (byTable !== undefined) {
+            return {
+                value: byTable,
+                resolvedFrom: 'builtin',
+            };
+        }
+        // 5. builtin default (mindig van — dsgn-007 §3 / §10.3).
         return {
             value: config_catalog_const_1.CONFIG_CATALOG[key].default,
             resolvedFrom: 'builtin',

package/build/src/app.server.js

@@ -6,6 +6,7 @@ const nts_dynamo_1 = require("@futdevpro/nts-dynamo");
 const logs_1 = require("@futdevpro/nts-dynamo/logs");
 const package_json_1 = require("../package.json");
 const fam_db_models_const_1 = require("./_collections/fam-db-models.const");
+const fam_remote_config_util_1 = require("./_collections/fam-remote-config.util");
 const api_controller_1 = require("./_routes/server/api/api.controller");
 const client_app_controller_1 = require("./_routes/server/client-app/client-app.controller");
 const errors_controller_1 = require("./_routes/server/errors/errors.controller");
@@ -31,6 +32,18 @@ class App extends nts_dynamo_1.DyNTS_App {
         const dbName = process.env.MONGODB_DB_NAME || 'fdp-agent-memory';
         // Connection-string: MONGODB_URI (dsgn-012 §7) vagy a régi MONGO_URL, vagy lokális default.
         const mongoBase = process.env.MONGODB_URI || process.env.MONGO_URL || 'mongodb://0.0.0.0:29017';
+        // TÁVOLI ELÉRÉS (user-FR 2026-07-28): a bind-host a `~/.fam/config.json` `bindHost`-jából (env felülírja).
+        // DEFAULT: loopback — a FAM-nak SZÁNDÉKOSAN nincs authja (ADR-004), ezért alapból NEM hallgatózik a hálózaton.
+        // A VM→host elérés EXPLICIT opt-in: `fam remote set --bind 0.0.0.0` (vagy a host-only adapter konkrét IP-je).
+        const bindHost = fam_remote_config_util_1.FAM_RemoteConfig_Util.resolveBindHost({
+            env: process.env.FAM_SERVER_HOST, file: fam_remote_config_util_1.FAM_RemoteConfig_Util.load(),
+        });
+        if (!fam_remote_config_util_1.FAM_RemoteConfig_Util.isLoopbackHost(bindHost)) {
+            fsm_dynamo_1.DyFM_Log.warn(`[FAM] TÁVOLI ELÉRÉS AKTÍV — a szerver a(z) '${bindHost}' címen hallgat, NEM csak loopbackon. `
+                + 'A FAM-nak NINCS authentikációja (ADR-004: lokális, single-user), ezért a hálózaton bárki '
+                + 'olvashatja/írhatja a TELJES tudás-korpuszt. Csak MEGBÍZHATÓ hálózaton (host-only VM-adapter / VPN) '
+                + 'használd; publikus/megosztott hálón NE. Visszaállítás: `fam remote set --bind 127.0.0.1`.');
+        }
         return new nts_dynamo_1.DyNTS_App_Params({
             name: 'FDP Agent Memory Server',
             title: title_const_1.FAM_title,
@@ -38,6 +51,7 @@ class App extends nts_dynamo_1.DyNTS_App {
             dbName: dbName,
             dbUri: `${mongoBase}/${dbName}`,
             systemShortCodeName: 'FAM',
+            openHost: bindHost,
         });
     }
     overrideDynamoNTSGlobalSettings() {

package/package.json

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