@futdevpro/fdp-agent-memory 0.1.0 → 1.1.12

package/build/src/_modules/embedding/_services/fam-embedding.control-service.js

@@ -5,6 +5,7 @@ const fsm_dynamo_1 = require("@futdevpro/fsm-dynamo");
 const error_codes_const_1 = require("../../../_collections/error-codes.const");
 const fam_error_factory_util_1 = require("../../../_collections/fam-error-factory.util");
 const config_control_service_1 = require("../../../_routes/server/config/config.control-service");
+const fam_embedding_prefix_util_1 = require("../_collections/fam-embedding-prefix.util");
 const fam_embedding_cost_control_service_1 = require("./fam-embedding-cost.control-service");
 const fam_lmstudio_embedding_provider_1 = require("./fam-lmstudio-embedding.provider");
 const fam_mock_embedding_provider_1 = require("./fam-mock-embedding.provider");
@@ -92,10 +93,19 @@ class FAM_Embedding_ControlService {
             fsm_dynamo_1.DyFM_Log.warn(`[FAM embedding cost-warn] ${decision.reason}`);
         }
         const provider = this.buildProvider(resolved, issuer);
+        // FEAT-004: task-prefix (query/document aszimmetria) — a provider-dispatch ELŐTT, a feloldott
+        // modell + callType alapján. A `mock` provider KIVÉTEL (`off`): a determinisztikus hash-en az
+        // aszimmetrikus prefix elrontaná a query↔doc egyezést (a teszt-double match-ét).
+        const prefixMode = resolved.provider === 'mock'
+            ? 'off'
+            : await this.resolveTaskPrefixMode({ table: set.table, scopePath: set.scopePath });
+        const texts = fam_embedding_prefix_util_1.FAM_EmbeddingPrefix_Util.apply({
+            texts: set.texts, modelId: resolved.modelId, callType: callType, mode: prefixMode,
+        });
         // Batch-elt dispatch (token-/rate-limit védelem; dsgn-007 embedding.batchSize).
         const allVectors = [];
-        for (let i = 0; i < set.texts.length; i += resolved.batchSize) {
-            const batch = set.texts.slice(i, i + resolved.batchSize);
+        for (let i = 0; i < texts.length; i += resolved.batchSize) {
+            const batch = texts.slice(i, i + resolved.batchSize);
             try {
                 const vectors = await provider.embedTexts({ texts: batch, model: resolved.modelId, issuer: issuer });
                 this.assertDimensions(vectors, resolved, issuer);
@@ -232,6 +242,15 @@ class FAM_Embedding_ControlService {
         }
         return process.env.OPENAI_EMBEDDING_MODEL || 'text-embedding-3-large';
     }
+    /**
+     * A task-prefix mód feloldása a config-precedencián (`embedding.taskPrefixMode`, FEAT-004). Ismeretlen /
+     * nem-enum érték → `auto` (a katalógus-default). A `mock`-provider-skip-et a hívó (`embedTexts`) kezeli.
+     */
+    async resolveTaskPrefixMode(context) {
+        const value = (await config_control_service_1.FAM_Config_ControlService.getInstance()
+            .resolve('embedding.taskPrefixMode', { table: context.table, scopePath: context.scopePath })).value;
+        return value === 'off' || value === 'on' || value === 'auto' ? value : 'auto';
+    }
     /** Az LM Studio base URL az ENV-ből (titok-szerű, nem DB; dsgn-006 §8). */
     lmStudioBaseUrl() {
         return process.env.LMSTUDIO_BASE_URL;

package/build/src/_modules/embedding/_services/fam-entry.data-service.js

@@ -1,7 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FAM_Entry_DataService = void 0;
+const tslib_1 = require("tslib");
 const nts_dynamo_1 = require("@futdevpro/nts-dynamo");
+const mongoose_1 = tslib_1.__importDefault(require("mongoose"));
 const fam_entry_data_model_1 = require("../../../_models/data-models/fam-entry.data-model");
 /**
  * `FAM_Entry_DataService` (SP-2.2) — egy GENERIKUS, tár-paraméteres entry-CRUD a vektor-rétegnek.
@@ -39,6 +41,68 @@ class FAM_Entry_DataService extends nts_dynamo_1.DyNTS_DataService {
     async findHydratableList(filter) {
         return this.findDataList(filter);
     }
+    /**
+     * PERF (FAM-REV / BFR-AM-013): a boot-hidratálás **lean + `{_id, contentVector}`-projekciós** variánsa.
+     * A pool-feltöltés (`hydrateTable`) CSAK az `_id`-t és a `contentVector`-t olvassa — a `content` szöveg,
+     * a metadata, a `scopePath`/`tags`/`kind` stb. a hidratáláshoz SOHA nem kell. Ezért: (1) `{_id:1,
+     * contentVector:1}`-projekció → a `content` (~1 KB/entry) NEM utazik; (2) `.lean()` → plain object,
+     * NINCS Mongoose-doc-hidratálás (ez a boot-OOM-kockázat fő forrása 35k doc-nál — FAM-REV-062). A
+     * `_deleted:null` az aktív-szűrő (a `findDataList` DB-szintű soft-delete-kizárását replikálja: a
+     * soft-delete `_deleted`-et `Date`-re állítja, az aktívon hiányzik/`null`). Model-hiány (boot-bootstrap
+     * előtt) → `findDataList`-fallback (korrekt, csak teljes-doc). Ugyanaz a minta, mint a candidate-prefilter
+     * (`FAM_RetrievalCandidate_DataService.findActiveCandidates`).
+     */
+    async findHydratableVectorsLean(filter) {
+        const dataName = this.dataParams.dataName;
+        const model = mongoose_1.default.models[dataName];
+        if (!model) {
+            return this.findDataList(filter);
+        }
+        const leanFilter = { ...filter, _deleted: null };
+        const docs = await model.find(leanFilter, { _id: 1, contentVector: 1 }).lean().exec();
+        // KRITIKUS (_id-konzisztencia): a `.lean()` NYERS ObjectId `_id`-t ad, de a pool-kulcsoknak a
+        // `findDataList`-tel AZONOS string `_id`-nek kell lenniük (a candidate-prefilter candidateIds-ai
+        // ehhez matchelnek; ObjectId-kulcs → 0 hit). Stringify, hogy a hidratált pool-kulcsok stringek legyenek.
+        for (const doc of docs) {
+            doc._id = String(doc._id);
+        }
+        return docs;
+    }
+    /**
+     * PERF (boot-csúcs): a `findHydratableVectorsLean` STREAMING (Mongoose-cursor) variánsa — a teljes
+     * (~23k-doc, ~486 MB `contentVector`-os) listát SOHA nem tartja egyben a memóriában, hanem doc-onként
+     * yield-eli az `onVector` callback-nek (a pool-építés közben a doc GC-zhető). Így a boot tranziens-csúcsa
+     * a teljes-lista-méretről (~486 MB) ~egy-doc-méretre csökken → kisebb boot-OOM-kockázat + a steady-state
+     * RSS alacsonyabb high-water-markra áll be (a `normalizedOnly` megtakarítás láthatóvá válik). Az `_id`
+     * stringify itt is kötelező (pool-kulcs-konzisztencia). Visszaadja a yield-elt (érvényes) vektorok számát.
+     * Model-hiány (boot-bootstrap előtt) → `findHydratableVectorsLean`-fallback (teljes-lista, korrekt).
+     */
+    async streamHydratableVectors(filter, onVector) {
+        const dataName = this.dataParams.dataName;
+        const model = mongoose_1.default.models[dataName];
+        if (!model) {
+            const docs = await this.findHydratableVectorsLean(filter);
+            let fallbackCount = 0;
+            for (const doc of docs) {
+                if (doc._id && doc.contentVector?.length) {
+                    onVector(String(doc._id), doc.contentVector);
+                    fallbackCount++;
+                }
+            }
+            return fallbackCount;
+        }
+        const leanFilter = { ...filter, _deleted: null };
+        const cursor = model.find(leanFilter, { _id: 1, contentVector: 1 }).lean().cursor();
+        let count = 0;
+        for await (const raw of cursor) {
+            const doc = raw;
+            if (doc._id && doc.contentVector?.length) {
+                onVector(String(doc._id), doc.contentVector);
+                count++;
+            }
+        }
+        return count;
+    }
     /**
      * Egy entry vektor-mezőinek ATOMIKUS frissítése (`$set`) — a Mixed silent-drop ellen. A
      * `contentVector` + `embeddingModel` + `embeddingStatus` + opc. `contentHash` egy lépésben.
@@ -60,5 +124,76 @@ class FAM_Entry_DataService extends nts_dynamo_1.DyNTS_DataService {
         const update = { $set: { embeddingStatus: status } };
         await this.updateData({ filterBy: { _id: id }, update: update });
     }
+    /**
+     * A felismert azonosító-kódok (`referenceCodes`) atomikus frissítése (`$set`) — FEAT-003 inverted-index.
+     * Az embed-sikertől FÜGGETLEN write (a write-path az embed ELŐTT hívja), így a kód-citáció a még nem
+     * embeddelt / embed-bukott elemen is megjelenik a determinisztikus read-expanzióban.
+     */
+    async setReferenceCodes(id, referenceCodes) {
+        const update = { $set: { referenceCodes: referenceCodes } };
+        await this.updateData({ filterBy: { _id: id }, update: update });
+    }
+    /**
+     * A scan-provenance `source.root` backfill-je (FAM-REV-048 kiegészítés) — a re-scan `equal`
+     * (változatlan-content) ágán hívva, hogy a metaadat-frissítés a content-skip ELLENÉRE megtörténjen.
+     * **FELTÉTELES** `$set`: csak akkor ír, ha a `source.root` hiányzik VAGY eltér (a Mongo-feltétel no-op,
+     * ha már stimmel), így a teljes korpusz root-tudatossá válik (törölt-fájl reconciliation-lefedettség)
+     * re-embed nélkül. Dot-path kulcs `$set`/filter — a Dynamo-típus loose-object útján (mint `setVector`).
+     */
+    async backfillSourceRoot(id, root) {
+        const setBlock = { ['source.root']: root };
+        const update = { $set: setBlock };
+        const filterBy = { _id: id };
+        filterBy['source.root'] = { $ne: root };
+        await this.updateData({ filterBy: filterBy, update: update });
+    }
+    /**
+     * A `sourceFilePath` (display-relatív út) FELTÉTELES backfill-je (FAM-REV-050) — a re-scan `equal` ágán
+     * hívva, hogy a default (basePath-nélküli) relatív út KONZISZTENS legyen, miután a fájl-identitás az
+     * `absolutePath`-ra állt át (egy korábban más scan-gyökérről — pl. `scan-file` basename — ingestelt chunk
+     * relatív útja a friss scan-gyökérhez igazodjon). Csak akkor ír, ha eltér (`$ne` — no-op, ha már stimmel).
+     */
+    async backfillSourceFilePath(id, relativePath) {
+        const update = { $set: { sourceFilePath: relativePath } };
+        const filterBy = { _id: id };
+        filterBy.sourceFilePath = { $ne: relativePath };
+        await this.updateData({ filterBy: filterBy, update: update });
+    }
+    /**
+     * A `referenceCodes` FELTÉTELES backfill-je (FEAT-003 + 2026-06-20 audit) — a re-scan `equal` ágán
+     * hívva, hogy a kód-index a content-skip ELLENÉRE frissüljön (pl. a Tailwind-denylist-bővítés a régi
+     * `equal`-chunkokra is érvényesüljön). Csak akkor ír, ha a tárolt tömb ELTÉR az újonnan kinyertől
+     * (`referenceCodes: {$ne}` — a Mongo no-op, ha egyezik); a `extract` determinisztikus sorrendje miatt
+     * a változatlan content ugyanazt a tömböt adja → nincs fölös write.
+     */
+    async backfillReferenceCodes(id, codes) {
+        const update = { $set: { referenceCodes: codes } };
+        const filterBy = { _id: id };
+        filterBy['referenceCodes'] = { $ne: codes };
+        await this.updateData({ filterBy: filterBy, update: update });
+    }
+    /**
+     * A `position` (chunk char/sor-offset) FELTÉTELES backfill-je (FAM-REV-061) — a re-scan `equal` ágán hívva,
+     * hogy a chunker pozíció-fix (a sliding-ablakok per-ablak abszolút charStart-ja) a régi `equal`-chunkokra is
+     * érvényesüljön, RE-EMBED NÉLKÜL (a pozíció a vektort nem érinti). Csak akkor ír, ha a `position.charStart`
+     * ELTÉR (a bug szimptómája: a nagy-blokk sub-chunkjai mind a blokk-kezdetre ütköztek) — a Mongo no-op, ha
+     * már stimmel. A friss `position` mind a négy mezőt felülírja (char/sor egyszerre számolt → konzisztens).
+     */
+    async backfillPosition(id, position) {
+        const setBlock = {
+            ['position.charStart']: position.charStart,
+            ['position.charEnd']: position.charEnd,
+        };
+        if (position.lineStart !== undefined) {
+            setBlock['position.lineStart'] = position.lineStart;
+        }
+        if (position.lineEnd !== undefined) {
+            setBlock['position.lineEnd'] = position.lineEnd;
+        }
+        const update = { $set: setBlock };
+        const filterBy = { _id: id };
+        filterBy['position.charStart'] = { $ne: position.charStart };
+        await this.updateData({ filterBy: filterBy, update: update });
+    }
 }
 exports.FAM_Entry_DataService = FAM_Entry_DataService;

package/build/src/_modules/embedding/_services/fam-vector-search.control-service.js

@@ -74,9 +74,17 @@ class FAM_VectorSearch_ControlService {
         this.poolDims.set(table, null);
         const dataService = new fam_entry_data_service_1.FAM_Entry_DataService({ dataParams: registryEntry.dataParams, issuer: this.issuer });
         const filter = { embeddingStatus: 'completed' };
-        let entries;
+        let loaded = 0;
         try {
-            entries = await dataService.findHydratableList(filter);
+            // PERF: lean + {_id, contentVector}-projekció + STREAMING (cursor) — a hidratálás CSAK ezt a két
+            // mezőt olvassa (nincs content-szöveg, nincs Mongoose-doc-hidratálás), ÉS doc-onként tölti a poolt
+            // (a teljes ~486 MB-os lista SOHA nincs egyben memóriában) → kisebb boot-csúcs + boot-OOM-kockázat.
+            await dataService.streamHydratableVectors(filter, (id, contentVector) => {
+                if (this.acceptVectorForPool(table, contentVector)) {
+                    pool.addVector(id, contentVector);
+                    loaded++;
+                }
+            });
         }
         catch (error) {
             throw fam_error_factory_util_1.FAM_Error_Util.create({
@@ -87,16 +95,6 @@ class FAM_VectorSearch_ControlService {
                 context: { operation: 'hydrate', table: table },
             });
         }
-        let loaded = 0;
-        for (const entry of entries) {
-            if (!entry._id || !entry.contentVector?.length) {
-                continue;
-            }
-            if (this.acceptVectorForPool(table, entry.contentVector)) {
-                pool.addVector(entry._id, entry.contentVector);
-                loaded++;
-            }
-        }
         this.hydrated.set(table, true);
         fsm_dynamo_1.DyFM_Log.log(`[FAM hydrate] '${table}' tár: ${loaded} vektor betöltve az in-memory pool-ba.`);
     }
@@ -143,7 +141,7 @@ class FAM_VectorSearch_ControlService {
             });
         }
         const pool = this.getOrCreatePool(input.table);
-        const poolSize = pool.getAll().size;
+        const poolSize = pool.size();
         if (!poolSize) {
             // Bootstrap-skip jelzés (dsgn-006 §4.1): üres pool (embedding nincs konfigurálva / nincs
             // completed entry). NEM néma — a capability + UI piros banner ezt jelzi (dsgn-008/dsgn-011).
@@ -166,7 +164,15 @@ class FAM_VectorSearch_ControlService {
     }
     /** Egy tár pool-jának mérete (a `test_vector_search` / `get_storage_usage` capability — dsgn-003). */
     getPoolSize(table) {
-        return this.getOrCreatePool(table).getAll().size;
+        return this.getOrCreatePool(table).size();
+    }
+    /**
+     * Egy tár pool-jának tényleges (megfigyelt) embedding-dimenziója (FAM-REV-044) — az első elfogadott
+     * vektornál rögzül (`acceptVectorForPool`). `null`, ha a pool még üres / nincs dimenzió. A
+     * `get_embedding_config` ezzel jelenti a runtime-valóságot a (gyakran null) deklarált dim mellett.
+     */
+    getPoolDim(table) {
+        return this.poolDims.get(table) ?? null;
     }
     /** Hidratált-e már egy tár (a bootstrap-skip diagnosztikához). */
     isHydrated(table) {
@@ -181,20 +187,13 @@ class FAM_VectorSearch_ControlService {
      * szűkített halmazra korlátozódik (a jelöltszám bizonyíthatóan kisebb a teljes tárnál — acceptance #4).
      */
     searchInCandidates(pool, queryVector, candidateIds, topK) {
-        const all = pool.getAll();
-        const scoped = new local_vector_search_1.LVS_VectorPool_ControlService();
-        let scopedCount = 0;
-        for (const id of candidateIds) {
-            const vector = all.get(id);
-            if (vector) {
-                scoped.addVector(id, vector);
-                scopedCount++;
-            }
-        }
-        if (!scopedCount) {
-            return [];
-        }
-        const results = scoped.search(queryVector, topK, local_vector_search_1.LVS_Search_Mode.cosineSimilarity);
+        // PERF (nts-dynamo ^1.15.71): a pool NATÍVAN szűr a candidate-ID halmazra — a MÁR előre-normalizált
+        // pool-on iterál, a nem-jelölteket `Set.has` O(1)-gyel kihagyja. Így NINCS per-query szűkített-pool-
+        // építés + a vektorok ÚJRA-normalizálása (a régi út 24k-jelöltnél ~24k l2Normalize-alloc + GC-spike-ot
+        // okozott; bench: unscoped 985ms → 90ms = 11×, scoped 37ms → 5ms = 7×, top-egyezés identikus). A
+        // pool ∩ candidateIds halmaz pontosan ugyanaz, mint a régi (a pool csak a hidratált entry-ket tartja).
+        const candidateSet = new Set(candidateIds);
+        const results = pool.search(queryVector, topK, local_vector_search_1.LVS_Search_Mode.cosineSimilarity, candidateSet);
         return results.map((hit) => ({ id: hit.id, score: hit.score }));
     }
     /** A query-vektor feloldása: kész `queryVector`, vagy a `queryText` embeddelése (provider-agnosztikus). */
@@ -216,18 +215,29 @@ class FAM_VectorSearch_ControlService {
     getOrCreatePool(table) {
         let pool = this.pools.get(table);
         if (!pool) {
-            pool = new local_vector_search_1.LVS_VectorPool_ControlService();
+            // PERF (nts-dynamo ^1.15.72): a FAM KIZÁRÓLAG cosine-keresést használ + SOSEM olvas nyers vektor-
+            // értéket (csak `size()` + `search(cosine)`), ezért a nyers `vectorPool` holt súly. `normalizedOnly`
+            // → a pool csak a normalizált másolatot tartja → ~50% pool-memória (35k vektor @2560-dim: ~700MB).
+            pool = new local_vector_search_1.LVS_VectorPool_ControlService({ normalizedOnly: true });
             this.pools.set(table, pool);
             this.poolDims.set(table, null);
         }
         return pool;
     }
     /**
-     * Dimenzió-homogenitás kapu (dsgn-006 §6.2 / acceptance #6): a pool első vektora rögzíti a
-     * dimenziót; az ettől eltérő dimenziójú vektort NEM vesszük fel (nem kever eltérő dimenziót egy
-     * tár pool-jában — a dimenzió-váltás explicit re-embedet igényel). Eltérés → warn (nem néma).
+     * Pool-felvételi kapu: (1) finiteség (NaN/±Inf-szűrés) + (2) dimenzió-homogenitás (dsgn-006 §6.2 /
+     * acceptance #6). A pool első vektora rögzíti a dimenziót; az ettől eltérő dimenziójú vektort NEM
+     * vesszük fel (a dimenzió-váltás explicit re-embedet igényel). Mindkét elutasítás warn (nem néma).
      */
     acceptVectorForPool(table, vector) {
+        // Finiteség-kapu (consumer-szintű BFR-AM-013 mitigáció): egy nem-véges (NaN/±Inf) elemű vektor
+        // némán megmérgezné a koszinusz-rangsort (a NaN-összehasonlítások kiejtik a valódi találatokat),
+        // ezért a pool-ba NEM kerül be. Az engine-szintű dot-product-guard továbbra is bedrock-igény.
+        if (!vector.every((value) => Number.isFinite(value))) {
+            fsm_dynamo_1.DyFM_Log.warn(`[FAM vector-pool] '${table}' tár nem-véges (NaN/±Inf) vektor-elem → kihagyva `
+                + `(hibás embedding / csonka write; BFR-AM-013).`);
+            return false;
+        }
         const current = this.poolDims.get(table);
         if (current === null || current === undefined) {
             this.poolDims.set(table, vector.length);

package/build/src/_modules/embedding/index.js

@@ -8,7 +8,7 @@
  * (BFR-AM-002/008); a bedrock-csere (MP-15) a `FAM_EmbeddingProvider` interfész mögött non-breaking.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.FAM_EmbeddingBootstrap_ControlService = exports.FAM_EmbeddingCost_ControlService = exports.FAM_EmbeddingPipeline_ControlService = exports.FAM_EmbeddingPreset_ControlService = exports.FAM_StoreRegistry_Util = exports.FAM_STORE_REGISTRY = exports.FAM_Entry_DataService = exports.FAM_VectorSearch_ControlService = exports.FAM_MOCK_EMBEDDING_DIMS = exports.FAM_Mock_EmbeddingProvider = exports.FAM_LMStudio_EmbeddingProvider = exports.FAM_OpenAI_EmbeddingProvider = exports.FAM_Embedding_ControlService = void 0;
+exports.FAM_EmbeddingBootstrap_ControlService = exports.FAM_DuplicateScan_ControlService = exports.FAM_EmbeddingCost_ControlService = exports.FAM_EmbeddingPipeline_ControlService = exports.FAM_EmbeddingPreset_ControlService = exports.FAM_StoreRegistry_Util = exports.FAM_STORE_REGISTRY = exports.FAM_Entry_DataService = exports.FAM_VectorSearch_ControlService = exports.FAM_MOCK_EMBEDDING_DIMS = exports.FAM_Mock_EmbeddingProvider = exports.FAM_LMStudio_EmbeddingProvider = exports.FAM_OpenAI_EmbeddingProvider = exports.FAM_Embedding_ControlService = void 0;
 // SP-2.1 — provider-dispatch kapu + providerek
 var fam_embedding_control_service_1 = require("./_services/fam-embedding.control-service");
 Object.defineProperty(exports, "FAM_Embedding_ControlService", { enumerable: true, get: function () { return fam_embedding_control_service_1.FAM_Embedding_ControlService; } });
@@ -35,6 +35,9 @@ var fam_embedding_pipeline_control_service_1 = require("./_services/fam-embeddin
 Object.defineProperty(exports, "FAM_EmbeddingPipeline_ControlService", { enumerable: true, get: function () { return fam_embedding_pipeline_control_service_1.FAM_EmbeddingPipeline_ControlService; } });
 var fam_embedding_cost_control_service_1 = require("./_services/fam-embedding-cost.control-service");
 Object.defineProperty(exports, "FAM_EmbeddingCost_ControlService", { enumerable: true, get: function () { return fam_embedding_cost_control_service_1.FAM_EmbeddingCost_ControlService; } });
+// near-duplikátum FELDERÍTŐ (read-only; user-direktíva 2026-06-21)
+var fam_duplicate_scan_control_service_1 = require("./_services/fam-duplicate-scan.control-service");
+Object.defineProperty(exports, "FAM_DuplicateScan_ControlService", { enumerable: true, get: function () { return fam_duplicate_scan_control_service_1.FAM_DuplicateScan_ControlService; } });
 // boot-hook (App.postProcess)
 var fam_embedding_bootstrap_control_service_1 = require("./_services/fam-embedding-bootstrap.control-service");
 Object.defineProperty(exports, "FAM_EmbeddingBootstrap_ControlService", { enumerable: true, get: function () { return fam_embedding_bootstrap_control_service_1.FAM_EmbeddingBootstrap_ControlService; } });

package/build/src/_modules/export/_collections/fam-export.const.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FAM_AUTHORED_SOURCE_TYPES = void 0;
+exports.isAuthoredSource = isAuthoredSource;
+/**
+ * FEAT-007 — a **non-file-derived** (kézzel / agent-írt) bejegyzés-források halmaza. Ezek a `source.type`-ok
+ * NEM regenerálhatók re-scan-nel: a `manual` (felhasználó kézzel írta) és az `agent` (agent-write) tartalom a
+ * **pótolhatatlan, kurált érték** — szemben a `scan` / `scan-summary` (fájlból generált, re-scan visszahozza)
+ * és az `import` (külső forrásból re-importálható) bejegyzésekkel. A backup/export ezekre fókuszál.
+ */
+exports.FAM_AUTHORED_SOURCE_TYPES = ['manual', 'agent'];
+/**
+ * Egy bejegyzés **authored** (non-file-derived, pótolhatatlan)-e a `source.type` alapján. A hiányzó/ismeretlen
+ * `source` defenzíven NEM authored (a fájl-derived túlsúly miatt biztonságos default — a backup nem hígul fel
+ * scan-elt elemekkel; a tényleges authored elemeknek mindig van `manual`/`agent` source-uk a write-úton).
+ */
+function isAuthoredSource(source) {
+    if (!source) {
+        return false;
+    }
+    return exports.FAM_AUTHORED_SOURCE_TYPES.includes(source.type);
+}

package/build/src/_modules/export/_services/fam-export.control-service.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FAM_Export_ControlService = void 0;
+const embedding_1 = require("../../embedding");
+const fam_export_const_1 = require("../_collections/fam-export.const");
+/**
+ * `FAM_Export_ControlService` (FEAT-007) — a **non-file-derived, pótolhatatlan** (kézzel/agent-írt) bejegyzések
+ * külön exportja/biztonsági mentése. A `scan`/`scan-summary` (fájlból re-scannelhető) és `import` (re-importálható)
+ * elemekkel szemben a `manual`/`agent` source-ú `memory`/`knowledge`/… bejegyzés re-scan-nel NEM regenerálható —
+ * ezt a kurált értéket menti ki a hívó (CLI `fam export` / `export_authored` capability) egy JSON-fájlba.
+ *
+ * **Mongo-szintű szűrés:** per-tár `findDataList({ 'source.type': $in [manual, agent] })` — az authored-halmaz
+ * kicsi (tipikusan tucatnyi), így a teljes-doc olvasás nem perf-gond; a `contentVector` az export-mappolásnál
+ * KIMARAD (a kurált CONTENT a pótolhatatlan, a vektor re-embeddel regenerálható). A `isAuthoredSource` helper a
+ * provenance-SSOT (a Mongo-filter mellett defenzív in-memory ellenőrzés).
+ *
+ * **FIGYELEM (memory: dynts_dataservice_eager_resolve):** per-tár lazy `new FAM_Entry_DataService` (nincs élő mező).
+ */
+class FAM_Export_ControlService {
+    issuer = 'FAM_Export_ControlService';
+    /**
+     * Az ÖSSZES tár authored (non-file-derived) bejegyzésének exportja. Tárakon iterál (`FAM_STORE_REGISTRY`),
+     * per-tár `source.type ∈ {manual, agent}`-re szűr, és a kurált mezőket adja vissza (a `contentVector` nélkül).
+     */
+    async exportAuthored() {
+        const byTable = {};
+        const entries = [];
+        for (const registryEntry of embedding_1.FAM_STORE_REGISTRY) {
+            const storeEntries = await this.loadAuthored(registryEntry);
+            byTable[registryEntry.table] = storeEntries.length;
+            for (const entry of storeEntries) {
+                entries.push(this.toExportEntry(entry, registryEntry.table));
+            }
+        }
+        return { formatVersion: 1, total: entries.length, byTable: byTable, entries: entries };
+    }
+    /** Egy tár authored bejegyzései (Mongo-filter `source.type $in [manual, agent]` + defenzív helper-szűrés). */
+    async loadAuthored(registryEntry) {
+        const dataService = new embedding_1.FAM_Entry_DataService({ dataParams: registryEntry.dataParams, issuer: this.issuer });
+        const filter = {};
+        filter['source.type'] = { $in: fam_export_const_1.FAM_AUTHORED_SOURCE_TYPES };
+        const storeEntries = await dataService.findDataList(filter);
+        // A helper a provenance-SSOT: a hiányzó/ismeretlen source defenzíven kizárandó (a Mongo-filter már szűrt).
+        return storeEntries.filter((entry) => (0, fam_export_const_1.isAuthoredSource)(entry.source));
+    }
+    /** Egy `FAM_Entry` → exportált authored-bejegyzés (a `contentVector` KIHAGYVA — re-embeddel regenerálható). */
+    toExportEntry(entry, table) {
+        return {
+            id: String(entry._id),
+            table: table,
+            content: entry.content ?? '',
+            source: entry.source,
+            kind: entry.kind,
+            tags: entry.tags,
+            weight: entry.weight,
+            scopePath: entry.scopePath,
+            referenceCodes: entry.referenceCodes,
+            headingPath: entry.headingPath,
+            createdMs: entry.__created ? new Date(entry.__created).getTime() : undefined,
+            lastModifiedMs: entry.__lastModified ? new Date(entry.__lastModified).getTime() : undefined,
+        };
+    }
+}
+exports.FAM_Export_ControlService = FAM_Export_ControlService;

package/build/src/_modules/export/index.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isAuthoredSource = exports.FAM_AUTHORED_SOURCE_TYPES = exports.FAM_Export_ControlService = void 0;
+var fam_export_control_service_1 = require("./_services/fam-export.control-service");
+Object.defineProperty(exports, "FAM_Export_ControlService", { enumerable: true, get: function () { return fam_export_control_service_1.FAM_Export_ControlService; } });
+var fam_export_const_1 = require("./_collections/fam-export.const");
+Object.defineProperty(exports, "FAM_AUTHORED_SOURCE_TYPES", { enumerable: true, get: function () { return fam_export_const_1.FAM_AUTHORED_SOURCE_TYPES; } });
+Object.defineProperty(exports, "isAuthoredSource", { enumerable: true, get: function () { return fam_export_const_1.isAuthoredSource; } });

package/build/src/_modules/ingest/_collections/fam-famignore.util.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FAM_FamIgnore_Util = void 0;
+const tslib_1 = require("tslib");
+const fs = tslib_1.__importStar(require("fs"));
+const path = tslib_1.__importStar(require("path"));
+/**
+ * `FAM_FamIgnore_Util` (descriptive user feedback / nagy-scan ergonómia) — a **`.fdpfamignore`** in-repo,
+ * gitignore-stílusú ignore-fájl támogatása. A projekt (vagy a workspace-gyökér) MAGÁBAN hordozza, mit hagyjon
+ * ki a FAM-scan — a config `scan.ignorePatterns` MELLETT (HOZZÁADÓDIK, nem felülír). A scan a `resolvedRoot`-ban
+ * lévő `.fdpfamignore`-t olvassa (scan-folder/scan-project; a scan-file egyetlen explicit fájlt céloz).
+ *
+ * **Szintaxis (gitignore-szerű, a `FAM_GlobMatch_Util`-ra fordítva):** soronként egy minta; `#` komment + üres
+ * sor kihagyva. `node_modules` (csupasz név) → bárhol illeszkedik; `/build` (vezető `/`) → a gyökérhez horgonyzott;
+ * `dist/` (záró `/`) → könyvtár; `src/gen` (beágyazott `/`) → gyökér-relatív; `*.tgz` → bárhol. **A `!` negáció
+ * v1-ben NEM támogatott** (a flat „matchesAny → skip" modellben — BACKLOG), az ilyen sorok kihagyva.
+ *
+ * **v1 hatókör:** a scan-GYÖKÉR `.fdpfamignore`-ja (a teljes scanre). A NESTED (per-alkönyvtár) `.fdpfamignore`
+ * a két-fázisú felderítés (walk → classify) miatt külön kör — BACKLOG (a `baseDir` paraméter már készen áll rá).
+ */
+class FAM_FamIgnore_Util {
+    /** Az ignore-fájl kanonikus neve. */
+    static FILENAME = '.fdpfamignore';
+    /**
+     * Egy `.fdpfamignore` tartalom → nyers minta-sorok (trim; `#`-komment + üres + `!`-negáció kihagyva).
+     * Tisztán pure — a fordítást (`toGlobPatterns`) külön végzi, hogy a parse önállóan tesztelhető legyen.
+     */
+    static parse(content) {
+        const result = [];
+        for (const rawLine of content.split(/\r?\n/)) {
+            const line = rawLine.trim();
+            if (!line || line.startsWith('#') || line.startsWith('!')) {
+                continue;
+            }
+            result.push(line);
+        }
+        return result;
+    }
+    /**
+     * Nyers gitignore-szerű minták → a `FAM_GlobMatch_Util` mintái (az ENTRY + a TARTALMA: `<base>` + `<base>/**`),
+     * a `baseDir` (root-relatív könyvtár, ahol az ignore-fájl van) elé fűzve. Horgonyzás: vezető `/` VAGY beágyazott
+     * `/` → a `baseDir`-hez horgonyzott; csupasz név → globális (bárhol-illeszkedő) prefix. A záró `/` (könyvtár-jel)
+     * levágva (a FAM a fájlt és a könyvtárat egyformán skip-eli).
+     */
+    static toGlobPatterns(lines, baseDir = '') {
+        const prefix = baseDir ? `${baseDir.replace(/\\/g, '/').replace(/\/+$/, '')}/` : '';
+        const patterns = [];
+        for (const rawLine of lines) {
+            let line = rawLine.trim();
+            const anchored = line.startsWith('/');
+            if (anchored) {
+                line = line.slice(1);
+            }
+            if (line.endsWith('/')) {
+                line = line.slice(0, -1);
+            }
+            if (!line) {
+                continue;
+            }
+            const base = (anchored || line.includes('/')) ? `${prefix}${line}` : `${prefix}**/${line}`;
+            patterns.push(base, `${base}/**`);
+        }
+        return patterns;
+    }
+    /**
+     * A `.fdpfamignore` beolvasása + fordítása egy könyvtárból (a `dirAbsolutePath`-ban). Hiányzó / olvashatatlan
+     * fájl → `[]` (opt-in: csak ha létezik). A `baseDir` a root-relatív horgony (a gyökér-szintű hívásnál `''`).
+     */
+    static loadFromDir(dirAbsolutePath, baseDir = '') {
+        try {
+            const filePath = path.join(dirAbsolutePath, FAM_FamIgnore_Util.FILENAME);
+            if (!fs.existsSync(filePath)) {
+                return [];
+            }
+            return FAM_FamIgnore_Util.toGlobPatterns(FAM_FamIgnore_Util.parse(fs.readFileSync(filePath, 'utf-8')), baseDir);
+        }
+        catch {
+            // Az ignore-fájl olvasás-hibája SOHA nem buktatja a scant (opt-in, best-effort).
+            return [];
+        }
+    }
+}
+exports.FAM_FamIgnore_Util = FAM_FamIgnore_Util;