@futdevpro/fdp-agent-memory 1.1.119 → 1.1.122

package/build/package.json

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

@@ -71,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,
@@ -84,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/_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.119",
+  "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": {