@futdevpro/fdp-agent-memory 0.1.0 → 1.1.14

package/build/src/_modules/mcp/_collections/fam-active-rules.util.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FAM_ActiveRules_Util = void 0;
+/**
+ * `FAM_ActiveRules_Util` (FEAT-005/006 P1) — a `get_active_rules` capability **pure** (DB-/provider-mentes)
+ * magja: a zóna-aktív `rules`-entry-k DETERMINISZTIKUS rendezése + kompakt row-ba képezése. A capability-
+ * handler (`FAM_CapabilityRegistry_Service.getActiveRules`) végzi a DB-orchestrációt (`expandForRead` +
+ * `loadCandidates`), és erre a util-ra delegálja a rendezést + a row-map-et — így a determinisztikus-sorrend
+ * szerződés (reprodukálható kimenet) önállóan unit-tesztelhető.
+ *
+ * **A `rules` per-tár mezők (`category`/`isActive`/`applicableScopes`/`dimensions`) a `FAM_Entry` bázison
+ * NINCSENEK** — a Mongo-doc-on igen; a loose `Partial<FAM_Rules_DataModel>` view a meglévő `as`-konvenció
+ * szerint olvassa (mint a retrieval `source`/`scopePath`).
+ */
+class FAM_ActiveRules_Util {
+    /**
+     * A zóna-aktív szabályok DETERMINISZTIKUS komparátora (a `sort` callback-je): weight DESC → category ASC →
+     * recency (`__lastModified`) DESC → `_id` ASC. A teljes lánc garantálja a stabil, reprodukálható sorrendet
+     * (nincs nondeterminizmus két azonos-súlyú szabálynál sem).
+     */
+    static compare(a, b) {
+        const weightDiff = (b.weight ?? 1) - (a.weight ?? 1);
+        if (weightDiff !== 0) {
+            return weightDiff;
+        }
+        const catA = a.category ?? '';
+        const catB = b.category ?? '';
+        if (catA !== catB) {
+            return catA < catB ? -1 : 1;
+        }
+        const recA = a.__lastModified ? new Date(a.__lastModified).getTime() : 0;
+        const recB = b.__lastModified ? new Date(b.__lastModified).getTime() : 0;
+        if (recA !== recB) {
+            return recB - recA;
+        }
+        return (a._id ?? '') < (b._id ?? '') ? -1 : 1;
+    }
+    /** Egy aktív `rules`-entry → kompakt `FAM_ActiveRuleRow` (a per-tár rule-mezőkkel; a `content` opcionális). */
+    static toRow(entry, includeContent) {
+        const rule = entry;
+        return {
+            id: entry._id,
+            content: includeContent ? entry.content : undefined,
+            kind: entry.kind,
+            category: rule.category,
+            isActive: rule.isActive ?? true,
+            applicableScopes: (rule.applicableScopes ?? []),
+            dimensions: rule.dimensions ?? [],
+            tags: entry.tags ?? [],
+            weight: entry.weight ?? 1,
+            scopePath: (entry.scopePath ?? []),
+            lastModifiedMs: entry.__lastModified ? new Date(entry.__lastModified).getTime() : 0,
+        };
+    }
+}
+exports.FAM_ActiveRules_Util = FAM_ActiveRules_Util;

package/build/src/_modules/mcp/_collections/fam-core-tools.const.js

@@ -9,7 +9,7 @@ const fam_capabilities_tool_service_1 = require("../_services/fam-capabilities-t
  * A 3 ADVERTISED MCP core-tool definíciója (SP-6.1/6.2/6.3/6.4, dsgn-003 §2/§3/§4/§5). EZ a
  * single-source a `read`/`write`/`capabilities` hirdetett tool-listához — a stdio `tools/list` PONTOSAN
  * ezt a 3-at adja vissza (dsgn-003 §6.1), a speciális eszközök NEM kerülnek ide (csak a
- * `FAM_CapabilityRegistry`-ben élnek — diszjunkció, dsgn-003 §6.6).
+ * `FAM_CapabilityRegistry_Service`-ben élnek — diszjunkció, dsgn-003 §6.6).
  *
  * Minden tool: agent-barát `description` (mely tár milyen tudást tárol, dsgn-003 §5) + JSON-schema
  * input + handler (a transport-agnosztikus core-service-re delegál; a REST UGYANEZT hívja).
@@ -57,6 +57,15 @@ const READ_INPUT_SCHEMA = {
                     scopeFilter: SCOPE_LAYER_ARRAY,
                     tagFilter: { type: 'array', items: { type: 'string' }, description: 'Tag-szűrő (OR).' },
                     kindFilter: { type: 'string', description: 'Egyetlen kind-szűrő.' },
+                    excludeIds: {
+                        type: 'array', items: { type: 'string' },
+                        description: 'A MÁR injektált bejegyzés-_id-k (FEAT-006 dedup): ezeket a találatból kizárjuk.',
+                    },
+                    depth: {
+                        type: 'string', enum: ['normal', 'deep'],
+                        description: 'Feltárás-mélység: `deep` → mély feltárás (sokkal több chunk; a `read.deepTopK` '
+                            + 'az alap topK helyett). Default `normal`. Az explicit `topK` mindig felülír.',
+                    },
                 },
                 required: ['tables', 'query'],
                 additionalProperties: false,
@@ -67,6 +76,13 @@ const READ_INPUT_SCHEMA = {
             description: 'Default true: a hit-ek `content`-tel térnek vissza (single-pass). false → kompakt lista.',
         },
         globalScopeFilter: SCOPE_LAYER_ARRAY,
+        basePath: {
+            type: 'string',
+            description: 'Opcionális abszolút bázis-útvonal (pl. a hívó agent workspace-gyökere): a találatok '
+                + '`sourceFilePath`-ja EHHEZ relatívan jön vissza (a kanonikus `absolutePath` belül tárolt, mindig '
+                + 'visszaadott). Enélkül a `sourceFilePath` a scan-gyökérhez relatív. Több workspace-locationről '
+                + 'futtatott agentekhez (FAM-REV-050).',
+        },
     },
     required: ['queries'],
     additionalProperties: false,
@@ -82,7 +98,10 @@ const WRITE_INPUT_SCHEMA = {
         operation: {
             type: 'string',
             enum: ['create', 'update', 'delete', 'scan-file', 'scan-folder', 'scan-project', 're-embed', 'import'],
-            description: 'A művelet (create/update/delete/scan-*/re-embed/import).',
+            description: 'A művelet (create/update/delete/scan-*/re-embed/import). ⚠️ scan-folder/scan-project ELŐTT '
+                + 'KÖTELEZŐ lépés: tegyél `.fdpfamignore`-t a scan-gyökérbe (node_modules/Library/__pycache__/'
+                + 'site-packages/dist/build/Logs… kizárása) — tisztán szkennelni OLCSÓBB, mint a beszkennelt junkot '
+                + 'utólag kitakarítani (törlés + re-embed drága).',
         },
         scopePath: SCOPE_LAYER_ARRAY,
         kind: { type: 'string', description: 'Opcionális kind (per-tár default).' },
@@ -93,9 +112,10 @@ const WRITE_INPUT_SCHEMA = {
         importance: { type: 'number', description: 'Opcionális kvalitatív hangsúly (0..1).' },
         target: {
             type: 'object',
-            description: 'update/delete cél-azonosítás.',
+            description: 'update/delete cél-azonosítás. DELETE-nél a `sourceFilePath`/`absolutePath` BULK '
+                + '(egy fájl ÖSSZES chunkja); az `absolutePath` a kanonikus egész-fájl-azonosító (FAM-REV-051).',
             properties: {
-                by: { type: 'string', enum: ['id', 'sourceFilePath', 'query'] },
+                by: { type: 'string', enum: ['id', 'sourceFilePath', 'absolutePath', 'query'] },
                 value: { type: 'string' },
             },
             required: ['by', 'value'],
@@ -103,12 +123,31 @@ const WRITE_INPUT_SCHEMA = {
         },
         scan: {
             type: 'object',
-            description: 'scan-* opciók (a scan-gyökér + glob-szűrők + dryRun).',
+            description: 'scan-* opciók (a scan-gyökér + glob-szűrők + dryRun + súly-kiemelés). ⚠️ TISZTA SCAN '
+                + 'ELŐFELTÉTEL: (1) ELŐBB hozz létre `.fdpfamignore`-t a `path`-ban (a node_modules/Library/'
+                + '__pycache__/site-packages/dist/build/coverage/Logs/obj/bin stb. kizárására — a default-ignore '
+                + 'fedi a gyakori junkot, de a projekt-specifikus mappákat ITT add hozzá); (2) futtass `dryRun:true`-t '
+                + 'ELLENŐRZÉSRE (fájl/chunk-szám). A beszkennelt junkot utólag kitakarítani (törlés + re-embed) '
+                + 'lényegesen drágább, mint eleve tisztán szkennelni.',
             properties: {
                 path: { type: 'string', description: 'A scan-gyökér (file/folder/project).' },
                 include: { type: 'array', items: { type: 'string' } },
                 exclude: { type: 'array', items: { type: 'string' } },
                 dryRun: { type: 'boolean', description: 'Csak felderítés (NINCS embed+persist).' },
+                weights: {
+                    type: 'array',
+                    description: 'Súly-kiemelés (FAM-REV-055): glob→súly, hogy a FONTOSABB fájlok chunkjai nagyobb '
+                        + 'retrieval-súlyt kapjanak (first-match-wins). Pl. [{pattern:"**/README.md", weight:5}].',
+                    items: {
+                        type: 'object',
+                        properties: {
+                            pattern: { type: 'string', description: 'Glob-minta (projekt-relatív útra).' },
+                            weight: { type: 'number', description: 'Retrieval-súly (>0; finalScore = score × weight).' },
+                        },
+                        required: ['pattern', 'weight'],
+                        additionalProperties: false,
+                    },
+                },
             },
             required: ['path'],
             additionalProperties: false,
@@ -164,7 +203,9 @@ exports.FAM_CORE_TOOLS = [
         name: 'write',
         description: 'Tudás mentése / módosítása / törlése / scan / re-embed / import — explicit, PONTOSAN 1 tár. '
             + 'A scope KÖTELEZŐ minden tartalom-műveletnél (create/scan-*/import). ' + TABLE_GUIDE
-            + ' A `delete` soft-delete; a scan automatikusan chunkol + embeddel (idempotens delta).',
+            + ' A `delete` soft-delete; a scan automatikusan chunkol + embeddel (idempotens delta). '
+            + '⚠️ scan-folder/scan-project ELŐTT: készíts `.fdpfamignore`-t a scan-gyökérbe + `dryRun:true`-zal '
+            + 'ellenőrizz (lásd a `scan` opciókat) — tisztán szkennelni olcsóbb, mint utólag takarítani.',
         inputSchema: WRITE_INPUT_SCHEMA,
         handler: async (args) => {
             const data = await fam_write_tool_service_1.FAM_WriteTool_Service.getInstance().handle(args);

package/build/src/_modules/mcp/_services/fam-capabilities-tool.service.js

@@ -9,7 +9,7 @@ const fam_capability_registry_service_1 = require("./fam-capability-registry.ser
  * Singleton. EGY belépési pont (`handle`), amit MIND az MCP-tool, MIND a REST `POST /capabilities` hív.
  *
  * Három action (dsgn-003 §4.1):
- *   - `list` → kategóriák + tool-nevek + egysoros leírás (a `FAM_CapabilityRegistry`-ből, single-source),
+ *   - `list` → kategóriák + tool-nevek + egysoros leírás (a `FAM_CapabilityRegistry_Service`-ből, single-source),
  *   - `describe(name)` → a tool teljes input-schema-ja + kategória + leírás,
  *   - `invoke(name, arguments)` → a capability handler futtatása + eredmény (vagy strukturált hiba).
  *
@@ -52,7 +52,7 @@ class FAM_CapabilitiesTool_Service {
     }
     /** `list` → kategória → tool-nevek + egysoros leírás (a registry single-source-ból). */
     handleList(category) {
-        const descriptors = fam_capability_registry_service_1.FAM_CapabilityRegistry.getInstance().list(category);
+        const descriptors = fam_capability_registry_service_1.FAM_CapabilityRegistry_Service.getInstance().list(category);
         const byCategory = {};
         for (const descriptor of descriptors) {
             const bucket = byCategory[descriptor.category] ?? [];
@@ -94,9 +94,9 @@ class FAM_CapabilitiesTool_Service {
                 context: { operation: operation },
             });
         }
-        const descriptor = fam_capability_registry_service_1.FAM_CapabilityRegistry.getInstance().get(name);
+        const descriptor = fam_capability_registry_service_1.FAM_CapabilityRegistry_Service.getInstance().get(name);
         if (!descriptor) {
-            const known = fam_capability_registry_service_1.FAM_CapabilityRegistry.getInstance().names();
+            const known = fam_capability_registry_service_1.FAM_CapabilityRegistry_Service.getInstance().names();
             throw fam_error_factory_util_1.FAM_Error_Util.create({
                 errorCode: error_codes_const_1.FAM_ERROR_CODES.mcpDispatchUnknownCapability,
                 message: `Ismeretlen capability: '${name}'. Elérhető (${known.length}): ${known.slice(0, 12).join(', ')}…. `

package/build/src/_modules/mcp/_services/fam-capability-registry.service.js

@@ -1,6 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.FAM_CapabilityRegistry = void 0;
+exports.FAM_CapabilityRegistry_Service = void 0;
+const tslib_1 = require("tslib");
+const mongoose_1 = tslib_1.__importDefault(require("mongoose"));
 const fam_table_type_enum_1 = require("../../../_enums/fam-table.type-enum");
 const error_codes_const_1 = require("../../../_collections/error-codes.const");
 const fam_error_factory_util_1 = require("../../../_collections/fam-error-factory.util");
@@ -9,14 +11,18 @@ const config_data_service_1 = require("../../../_routes/server/config/config.dat
 const errors_control_service_1 = require("../../../_routes/server/errors/errors.control-service");
 const embedding_1 = require("../../embedding");
 const ingest_1 = require("../../ingest");
+const export_1 = require("../../export");
+const capture_1 = require("../../capture");
 const retrieval_1 = require("../../retrieval");
 const migration_1 = require("../../migration");
 const scope_reference_1 = require("../../scope-reference");
+const fam_reference_data_model_1 = require("../../../_models/data-models/fam-reference.data-model");
 const fam_mcp_interface_1 = require("../_models/interfaces/fam-mcp.interface");
+const fam_active_rules_util_1 = require("../_collections/fam-active-rules.util");
 /** A főtár-nevek a `list_tables` / `get_table_stats` capability-khez. */
 const MAIN_TABLES = embedding_1.FAM_STORE_REGISTRY.map((entry) => entry.table);
 /**
- * `FAM_CapabilityRegistry` (SP-6.4, dsgn-003 §4.2) — a **discoverable speciális eszközök** belső
+ * `FAM_CapabilityRegistry_Service` (SP-6.4, dsgn-003 §4.2) — a **discoverable speciális eszközök** belső
  * registry-je. Singleton. A 6 kategória (config-diagnostics / high-level-stats / inspection /
  * maintenance / import-migration / debug) minden eszköze ITT él (név + kategória + leírás + schema +
  * handler), és **kizárólag** a `capabilities` tool-on át érhető el (`list`/`describe`/`invoke`).
@@ -30,20 +36,20 @@ const MAIN_TABLES = embedding_1.FAM_STORE_REGISTRY.map((entry) => entry.table);
  * Az import/migration + néhány még-nem-épült engine handler **late-bind** (clear "pending MP-X" hiba az
  * `invoke`-on; a `list`/`describe` ettől teljes).
  */
-class FAM_CapabilityRegistry {
+class FAM_CapabilityRegistry_Service {
     static _instance;
     /** A capability-eszközök `name` → deszkriptor map-je (a single-source katalógus). */
     registry = new Map();
     /** Default issuer (a capability-hibák issuer-éhez; dsgn-008). */
-    issuer = 'FAM_CapabilityRegistry';
+    issuer = 'FAM_CapabilityRegistry_Service';
     constructor() {
         this.registerAll();
     }
     static getInstance() {
-        if (!FAM_CapabilityRegistry._instance) {
-            FAM_CapabilityRegistry._instance = new FAM_CapabilityRegistry();
+        if (!FAM_CapabilityRegistry_Service._instance) {
+            FAM_CapabilityRegistry_Service._instance = new FAM_CapabilityRegistry_Service();
         }
-        return FAM_CapabilityRegistry._instance;
+        return FAM_CapabilityRegistry_Service._instance;
     }
     // =========================================================================
     // Public registry API (a `capabilities` tool — SP-6.4 — fogyasztja)
@@ -92,13 +98,15 @@ class FAM_CapabilityRegistry {
         });
         this.register({
             name: 'get_embedding_config', category: category,
-            description: 'A feloldott embedding-provider + modell + dimenzió + batch-méret az adott kontextusra.',
+            description: 'A feloldott embedding-provider + modell + (deklarált + megfigyelt) dimenzió + batch-méret.',
             inputSchema: this.objectSchema({ table: this.tableSchema(false) }),
             handler: async (args) => {
                 const input = this.asObject(args);
-                const probe = await embedding_1.FAM_Embedding_ControlService.getInstance()
-                    .testProvider({ table: this.optionalTable(input.table) });
-                return this.ok(probe.resolved);
+                const table = this.optionalTable(input.table);
+                const probe = await embedding_1.FAM_Embedding_ControlService.getInstance().testProvider({ table: table });
+                // FAM-REV-044: a deklarált `dims` gyakran null (modell-natív); a `observedDims` a runtime-valóság
+                // a vektor-pool-ból (pl. 2560 a qwen3-4b-nél) — informatív + modell-váltás-detekció alapja.
+                return this.ok({ ...probe.resolved, observedDims: this.observedPoolDim(table) });
             },
         });
         this.register({
@@ -283,6 +291,25 @@ class FAM_CapabilityRegistry {
                 return this.ok(await this.recentWrites(this.optionalTable(input.table), this.asNumber(input.limit)));
             },
         });
+        // get_active_rules (FEAT-005/006 P1) — egy zóna AKTÍV szabályai DETERMINISZTIKUSAN (vektor NÉLKÜL):
+        // a context-injekció adat-primitívje, amit a (jövőbeli) hook zóna-belépéskor hív. REUSE: `expandForRead`
+        // (scope→subtree) + `loadCandidates` (a beépített `isActive≠false` + soft-delete guarddal) — NEM új query-logika.
+        this.register({
+            name: 'get_active_rules', category: category,
+            description: 'Egy zóna (scope) AKTÍV szabályai — DETERMINISZTIKUS, vektorkeresés NÉLKÜLI lista '
+                + '(`isActive≠false` + a scope-subtree-be eső `rules`-entry-k), súly (weight) szerint rendezve, '
+                + 'mindegyik a `category`/`isActive`/`applicableScopes`-szal. A FEAT-005/006 kontextus-injekció '
+                + 'adat-primitívje: a hook ezt hívja zóna-belépéskor (a „mindig-aktív szabályok" forrása). '
+                + 'scopePath nélkül → a teljes `rules` tár aktív szabályai.',
+            inputSchema: this.objectSchema({
+                scopePath: this.scopeLayerArraySchema(),
+                includeContent: { type: 'boolean', description: 'A szabály-content visszaadása (default true).' },
+            }),
+            handler: async (args) => {
+                const input = this.asObject(args);
+                return this.ok(await this.getActiveRules(this.asScopeLayers(input.scopePath), input.includeContent !== false));
+            },
+        });
     }
     /** maintenance → MP-2 (re-embed) + MP-3 (rebuild reference index). */
     registerMaintenance() {
@@ -318,6 +345,54 @@ class FAM_CapabilityRegistry {
             inputSchema: this.objectSchema({}),
             handler: async () => this.ok(await scope_reference_1.FAM_ScopeResolver_ControlService.getInstance().rebuildReferenceIndex()),
         });
+        this.register({
+            name: 'export_authored', category: category,
+            description: 'FEAT-007: a non-file-derived (kézzel/agent-írt, `source.type ∈ {manual, agent}`) bejegyzések '
+                + 'exportja MINDEN tárból — a re-scan-nel NEM regenerálható, pótolhatatlan kurált érték biztonsági '
+                + 'mentése (a `contentVector` nélkül; a hívó/CLI JSON-fájlba írja).',
+            inputSchema: this.objectSchema({}),
+            handler: async () => this.ok(await new export_1.FAM_Export_ControlService().exportAuthored()),
+        });
+        this.register({
+            name: 'auto_capture', category: category,
+            description: 'FEAT-006: hook-vezérelt outbound session-observation auto-write a `memory`-tárba, '
+                + 'content-hash deduppal (idempotens — azonos tartalom NEM duplikálódik). Agent-provenance + '
+                + 'auto-embed; a scope default-ol, ha nincs megadva. A claude-mem auto-capture-paritás magja.',
+            inputSchema: this.objectSchema({
+                content: { type: 'string', description: 'A megfigyelés vektorizálandó szövege (kötelező).' },
+                scopePath: this.scopeLayerArraySchema(),
+                tags: { type: 'array', items: { type: 'string' }, description: 'Opcionális tagek.' },
+                kind: { type: 'string', description: 'Opcionális kind (default `observation`).' },
+                sessionId: { type: 'string', description: 'Opcionális session-azonosító (provenance a `source.path`-ban).' },
+            }),
+            handler: async (args) => {
+                const input = this.asObject(args);
+                return this.ok(await capture_1.FAM_AutoCapture_ControlService.getInstance().capture({
+                    content: input.content,
+                    scopePath: this.asScopeLayers(input.scopePath),
+                    tags: Array.isArray(input.tags) ? input.tags : undefined,
+                    kind: typeof input.kind === 'string' ? input.kind : undefined,
+                    sessionId: typeof input.sessionId === 'string' ? input.sessionId : undefined,
+                }));
+            },
+        });
+        this.register({
+            name: 'manage_reference', category: category,
+            description: 'Reference (alias-/fogalom-feloldás, disambiguáció) létrehozása/frissítése: `canonicalTerm` '
+                + '+ `aliasTerms` (ezek → a canonical) + `negativeAliases` (ezeket a reference EXPLICIT NEM oldja fel '
+                + '— „ne keverj dolgokat") + opcionális scope-kötés (`scopePath` → canonicalScopeRef). A friss '
+                + 'reference AZONNAL feloldódik (index-rebuild). Idempotens: `id` VAGY a `canonicalTerm` alapján upsert.',
+            inputSchema: this.objectSchema({
+                canonicalTerm: { type: 'string', description: 'A canonical (helyes) terminus — KÖTELEZŐ.' },
+                aliasTerms: { type: 'array', items: { type: 'string' }, description: 'Pozitív aliasok (typo/rövid/variáns → a canonical).' },
+                negativeAliases: { type: 'array', items: { type: 'string' }, description: 'NEGATÍV aliasok: ezeket a reference EXPLICIT NEM oldja fel (disambiguáció).' },
+                description: { type: 'string', description: 'Mit jelent / mire való (a vektor-fuzzy-hoz is).' },
+                referenceCategory: { type: 'string', description: 'A reference kategóriája (project|package|concept|person|organization).' },
+                scopePath: this.scopeLayerArraySchema(),
+                id: { type: 'string', description: 'Meglévő reference _id (frissítéshez; egyébként canonicalTerm-upsert).' },
+            }),
+            handler: async (args) => this.ok(await this.manageReference(this.asObject(args))),
+        });
         // repair_scope_links / deduplicate_entries (MP-12) — DRY-RUN-ONLY MVP1 (safe). A destruktív
         // write-ág (entry-mutáció / soft-delete-összevonás) BACKLOG: vak destruktív bulk-op TILOS
         // (dsgn-003 §4.2), ezért a `dryRun:false` kérés clear "BACKLOG" hibát ad — a `dryRun:true` (default)
@@ -641,9 +716,37 @@ class FAM_CapabilityRegistry {
         }
         return Array.from(byLayer.entries()).map(([layer, bucket]) => ({ layer: layer, ...bucket }));
     }
+    /**
+     * A megfigyelt (runtime) embedding-dimenzió a vektor-pool-ból (FAM-REV-044). A megadott tár pool-dim-je,
+     * vagy tár nélkül az első nem-null fő-tár dim. `null`, ha minden pool üres (még nem volt embed).
+     */
+    observedPoolDim(table) {
+        const vectorSearch = embedding_1.FAM_VectorSearch_ControlService.getInstance();
+        if (table) {
+            return vectorSearch.getPoolDim(table);
+        }
+        for (const candidate of MAIN_TABLES) {
+            const dim = vectorSearch.getPoolDim(candidate);
+            if (dim !== null) {
+                return dim;
+            }
+        }
+        return null;
+    }
+    /**
+     * Egy modell-névhez (`dataName`) a TÉNYLEGES Mongoose-collection-név (FAM-REV-043). A Mongoose
+     * pluralizál (pl. `fam_codebase` → `fam_codebases`); a már regisztrált modellből olvassuk ki a valós
+     * nevet (a `storageUsage` a data-service-eket előbb példányosítja, így a modell regisztrált). Fallback a
+     * `dataName`, ha a modell még nincs regisztrálva (no-regression).
+     */
+    realCollectionName(dataName) {
+        const model = mongoose_1.default.models[dataName];
+        return model?.collection?.collectionName ?? dataName;
+    }
     /**
      * `get_storage_usage` (MP-12) — a fő RAG-tárak + a helper collection-ök aktív doc-száma. A Dynamo
      * base-nek nincs natív `count`, ezért aktív-elemszám (`findDataList(...).length`) — collection-méret-becslés.
+     * A `collection` a TÉNYLEGES (Mongoose-pluralizált) név (FAM-REV-043).
      */
     async storageUsage() {
         const collections = [];
@@ -651,21 +754,110 @@ class FAM_CapabilityRegistry {
         for (const registryEntry of embedding_1.FAM_STORE_REGISTRY) {
             const dataService = new embedding_1.FAM_Entry_DataService({ dataParams: registryEntry.dataParams, issuer: this.issuer });
             const entries = await dataService.findHydratableList({});
-            collections.push({ collection: `fam_${registryEntry.table}`, activeDocs: entries.length });
+            collections.push({ collection: this.realCollectionName(registryEntry.dataParams.dataName), activeDocs: entries.length });
         }
-        // Helper collection-ök (reference / scope / ingest-run / config).
+        // Helper collection-ök (reference / scope / ingest-run / config) — a DS-példányosítás regisztrálja a modellt.
         const reference_DS = new scope_reference_1.FAM_Reference_DataService({ issuer: this.issuer });
-        collections.push({ collection: 'fam_reference', activeDocs: (await reference_DS.findActive()).length });
+        collections.push({ collection: this.realCollectionName('fam_reference'), activeDocs: (await reference_DS.findActive()).length });
         const scope_DS = new scope_reference_1.FAM_Scope_DataService({ issuer: this.issuer });
-        collections.push({ collection: 'fam_scopes', activeDocs: (await scope_DS.findAllActive()).length });
+        collections.push({ collection: this.realCollectionName('fam_scopes'), activeDocs: (await scope_DS.findAllActive()).length });
         const run_DS = new ingest_1.FAM_IngestRun_DataService({ issuer: this.issuer });
-        collections.push({ collection: 'fam_ingest_runs', activeDocs: (await run_DS.listRuns()).length });
+        collections.push({ collection: this.realCollectionName('fam_ingest_runs'), activeDocs: (await run_DS.listRuns()).length });
         const config_DS = new config_data_service_1.FAM_Config_DataService({ issuer: this.issuer });
-        collections.push({ collection: 'fam_config', activeDocs: (await config_DS.findActiveList({})).length });
+        collections.push({ collection: this.realCollectionName('fam_config'), activeDocs: (await config_DS.findActiveList({})).length });
         const totalActiveDocs = collections.reduce((sum, entry) => sum + entry.activeDocs, 0);
         return { collections: collections, totalActiveDocs: totalActiveDocs };
     }
     // =========================================================================
+    // FEAT-005/006 P1: get_active_rules (zóna-aktív szabályok — determinisztikus)
+    // =========================================================================
+    /**
+     * `get_active_rules` (FEAT-005/006 P1) — egy zóna (scope) AKTÍV szabályainak DETERMINISZTIKUS, vektor-
+     * keresés NÉLKÜLI listája. REUSE (nincs új query-logika): a `expandForRead` a scope-filtert subtree-
+     * scopeId-halmazzá oldja (UGYANÚGY, mint a `read`), a `loadCandidates` pedig a `rules`-tárból a beépített
+     * `isActive≠false` + soft-delete guarddal szűr — itt NINCS vektor-lépés, az ÖSSZES aktív szabály visszajön.
+     * Rendezés: weight DESC → category ASC → recency DESC → `_id` ASC (stabil, reprodukálható). scopePath
+     * nélkül → a teljes `rules` tár (scopeIdSet=null). Ez a primitív, amit a FEAT-006 hook zóna-belépéskor hív.
+     */
+    async getActiveRules(rawScope, includeContent) {
+        const expand = await scope_reference_1.FAM_ScopeResolver_ControlService.getInstance()
+            .expandForRead(rawScope.length ? rawScope : undefined);
+        const candidates = await new retrieval_1.FAM_RetrievalCandidate_DataService().loadCandidates({
+            table: fam_table_type_enum_1.FAM_Table.rules,
+            scopeIdSet: expand.scopeIdSet,
+        });
+        candidates.sort(fam_active_rules_util_1.FAM_ActiveRules_Util.compare);
+        return {
+            scopeFilter: rawScope.map((layer) => ({ layer: layer.layer, rawName: layer.rawName })),
+            count: candidates.length,
+            deterministic: true,
+            rules: candidates.map((entry) => fam_active_rules_util_1.FAM_ActiveRules_Util.toRow(entry, includeContent)),
+            uncertaintyNotes: expand.uncertaintyNotes,
+        };
+    }
+    /**
+     * `manage_reference` — reference (alias-/fogalom-feloldás + disambiguáció) idempotens upsert-je. A
+     * `negativeAliases` a „ne keverj dolgokat" veto (a reference EXPLICIT nem oldja fel azokat a tokeneket).
+     * Idempotencia: `id` VAGY a normalizált `canonicalTerm` alapján. Opcionális `scopePath` → `canonicalScopeRef`
+     * (a write-resolve leaf-je). A `saveData` után index-rebuild → a friss reference AZONNAL feloldódik.
+     */
+    async manageReference(input) {
+        const canonicalTerm = this.asString(input.canonicalTerm);
+        if (!canonicalTerm) {
+            throw fam_error_factory_util_1.FAM_Error_Util.create({
+                errorCode: error_codes_const_1.FAM_ERROR_CODES.mcpDispatchUnknownCapability,
+                message: 'A `manage_reference`-hez a `canonicalTerm` (string) KÖTELEZŐ.',
+                issuer: this.issuer, context: { operation: 'capability-invoke:manage_reference' },
+            });
+        }
+        const referenceDataService = new scope_reference_1.FAM_Reference_DataService({ issuer: this.issuer });
+        // Opcionális scope-kötés → canonicalScopeRef (a write-resolve leaf-je).
+        let canonicalScopeRef;
+        let scopeLayer;
+        const rawScope = this.asScopeLayers(input.scopePath);
+        if (rawScope.length) {
+            const resolved = await scope_reference_1.FAM_ScopeResolver_ControlService.getInstance().resolveForWrite(rawScope);
+            canonicalScopeRef = resolved.scopePath[resolved.scopePath.length - 1];
+            scopeLayer = canonicalScopeRef?.layer;
+        }
+        // Meglévő reference (id VAGY normalizált canonicalTerm) → upsert.
+        const id = this.asString(input.id);
+        let existing;
+        if (id) {
+            existing = await referenceDataService.findReferenceById(id);
+        }
+        else {
+            const target = scope_reference_1.FAM_ScopeNormalize_Util.normalize(canonicalTerm);
+            existing = (await referenceDataService.findActive())
+                .find((reference) => scope_reference_1.FAM_ScopeNormalize_Util.normalize(reference.canonicalTerm) === target);
+        }
+        const model = new fam_reference_data_model_1.FAM_Reference_DataModel({
+            _id: existing?._id,
+            canonicalTerm: canonicalTerm,
+            aliasTerms: this.asStringList(input.aliasTerms),
+            negativeAliases: this.asStringList(input.negativeAliases),
+            description: this.asString(input.description),
+            category: this.asString(input.referenceCategory) ?? 'concept',
+            scopeLayer: scopeLayer,
+            canonicalScopeRef: canonicalScopeRef,
+        });
+        const saved = await referenceDataService.saveData(model);
+        await scope_reference_1.FAM_ScopeResolver_ControlService.getInstance().rebuildReferenceIndex();
+        return {
+            ok: true, referenceId: saved._id, created: !existing, canonicalTerm: canonicalTerm,
+            aliasTerms: model.aliasTerms, negativeAliases: model.negativeAliases,
+            scope: canonicalScopeRef?.canonicalName,
+        };
+    }
+    /** Egy érték string-tömbként (a nem-string elemek kiszűrve; üres/nem-tömb → undefined). */
+    asStringList(value) {
+        if (!Array.isArray(value)) {
+            return undefined;
+        }
+        const list = value.filter((item) => typeof item === 'string' && item.length > 0);
+        return list.length ? list : undefined;
+    }
+    // =========================================================================
     // MP-12 inspection: kinds/tags / recent-writes
     // =========================================================================
     /** `list_kinds_tags` (MP-12) — per-tár distinct kind/tag eloszlás (előfordulás-szám) az aktív entry-kből. */
@@ -1017,6 +1209,16 @@ class FAM_CapabilityRegistry {
             },
             path: { type: 'string', description: 'export-JSON/SQLite útvonal VAGY worker base-URL.' },
             includePrompts: { type: 'boolean', description: 'A user_prompt-ok be-importálása (default false).' },
+            excludeTypes: {
+                type: 'array', items: { type: 'string' },
+                description: 'Kurált-subset (L3 „A"): kihagyandó observation-type-ok, pl. ["discovery","change"] '
+                    + '(a low-signal bulk; a summary/prompt marad). A preview is a szűrt halmazt mutatja.',
+            },
+            maxRecords: {
+                type: 'number',
+                description: 'Teszt-/biztonsági limit: a beolvasott+szűrt rekordok max-száma (a többi levágva), '
+                    + 'pl. egy kis teszt-import a pipeline ellenőrzésére a teljes import előtt.',
+            },
         });
     }
     /** A map/run import-schema: a forrás-schema + az `overrides` blokk (byType/byId/scope/includePrompts). */
@@ -1039,6 +1241,10 @@ class FAM_CapabilityRegistry {
             from: this.asImportFrom(input.from),
             path: this.asString(input.path),
             includePrompts: typeof input.includePrompts === 'boolean' ? input.includePrompts : undefined,
+            excludeTypes: Array.isArray(input.excludeTypes)
+                ? input.excludeTypes.filter((value) => typeof value === 'string')
+                : undefined,
+            maxRecords: typeof input.maxRecords === 'number' ? input.maxRecords : undefined,
             overrides: this.asImportOverrides(input.overrides),
         };
     }
@@ -1177,4 +1383,4 @@ class FAM_CapabilityRegistry {
         return { table: table, scopePath: expand.scopePath };
     }
 }
-exports.FAM_CapabilityRegistry = FAM_CapabilityRegistry;
+exports.FAM_CapabilityRegistry_Service = FAM_CapabilityRegistry_Service;

package/build/src/_modules/mcp/_services/fam-mcp-adapter.service.js

@@ -1,12 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.FAM_Mcp_Adapter = void 0;
+exports.FAM_Mcp_Adapter_Service = void 0;
 const index_js_1 = require("@modelcontextprotocol/sdk/server/index.js");
 const stdio_js_1 = require("@modelcontextprotocol/sdk/server/stdio.js");
 const types_js_1 = require("@modelcontextprotocol/sdk/types.js");
 const fsm_dynamo_1 = require("@futdevpro/fsm-dynamo");
 /**
- * `FAM_Mcp_Adapter` (SP-6.1, BFR-AM-003 workaround) — a hivatalos `@modelcontextprotocol/sdk` köré
+ * `FAM_Mcp_Adapter_Service` (SP-6.1, BFR-AM-003 workaround) — a hivatalos `@modelcontextprotocol/sdk` köré
  * épített **vékony adaptor-réteg**. EGY `registerTool` choke-pont + a `tools/list` / `tools/call`
  * JSON-RPC handler-ek bekötése — semmi domain-logika. Így a bedrock `DyNTS_Mcp_ServerBase` (MP-15)
  * landolásakor CSAK ez az osztály cserélődik; a 3 core tool + a capability-registry kód változatlan.
@@ -19,7 +19,7 @@ const fsm_dynamo_1 = require("@futdevpro/fsm-dynamo");
  * strukturált `CallToolResult { isError:true, content }`-tá fordul — soha nem néma, soha nem crash-el
  * a szerver. A handler `FAM_McpToolOutcome.isError` is ide képződik.
  */
-class FAM_Mcp_Adapter {
+class FAM_Mcp_Adapter_Service {
     /** A SDK MCP-szerver (a transport-agnosztikus protocol-réteg). */
     server;
     /** A regisztrált tool-definíciók `name` → def map-je (a `tools/call` dispatch-hez). */
@@ -120,4 +120,4 @@ class FAM_Mcp_Adapter {
         }
     }
 }
-exports.FAM_Mcp_Adapter = FAM_Mcp_Adapter;
+exports.FAM_Mcp_Adapter_Service = FAM_Mcp_Adapter_Service;

package/build/src/_modules/mcp/_services/fam-mcp-server.service.js

@@ -7,7 +7,7 @@ const fam_capability_registry_service_1 = require("./fam-capability-registry.ser
 const fam_mcp_adapter_service_1 = require("./fam-mcp-adapter.service");
 /**
  * `FAM_McpServer_Service` (SP-6.1, dsgn-003 §1/§5/§6) — az MCP-szerver orchestrátora. Singleton.
- * Felelősség: a `FAM_Mcp_Adapter`-be regisztrálja a **PONTOSAN 3** advertised core-tool-t
+ * Felelősség: a `FAM_Mcp_Adapter_Service`-be regisztrálja a **PONTOSAN 3** advertised core-tool-t
  * (`read`/`write`/`capabilities`), példányosítja a capability-registry-t (a discoverable speciális
  * eszközök single-source-a — diszjunkt halmaz, dsgn-003 §6.6), és a stdio transporton elindítja a
  * szervert (`start`).
@@ -35,14 +35,14 @@ class FAM_McpServer_Service {
      * smoke: a szerver felépül + 3 tool-t hirdet, transport nélkül).
      */
     build(set) {
-        const adapter = new fam_mcp_adapter_service_1.FAM_Mcp_Adapter({ name: set.name, version: set.version });
+        const adapter = new fam_mcp_adapter_service_1.FAM_Mcp_Adapter_Service({ name: set.name, version: set.version });
         // A PONTOSAN 3 advertised core-tool regisztrálása (a single-source `FAM_CORE_TOOLS`-ból).
         for (const tool of fam_core_tools_const_1.FAM_CORE_TOOLS) {
             adapter.registerTool(tool);
         }
         // A capability-registry példányosítása (a discoverable speciális eszközök katalógusa) — ezek
         // NEM advertised tool-ok, csak a `capabilities` tool-on át elérhetők (diszjunkció).
-        fam_capability_registry_service_1.FAM_CapabilityRegistry.getInstance();
+        fam_capability_registry_service_1.FAM_CapabilityRegistry_Service.getInstance();
         this.adapter = adapter;
         return adapter;
     }
@@ -63,7 +63,7 @@ class FAM_McpServer_Service {
     }
     /** A discoverable capability-nevek (a diszjunkció-teszthez: ezek SOHA nem advertised). */
     getCapabilityNames() {
-        return fam_capability_registry_service_1.FAM_CapabilityRegistry.getInstance().names();
+        return fam_capability_registry_service_1.FAM_CapabilityRegistry_Service.getInstance().names();
     }
 }
 exports.FAM_McpServer_Service = FAM_McpServer_Service;