@futdevpro/fdp-agent-memory 1.1.30 → 1.1.113

package/build/src/_models/data-models/fam-scope.data-model.js

@@ -21,6 +21,14 @@ class FAM_Scope_DataModel extends fsm_dynamo_1.DyFM_Metadata {
     parentScopeId;
     /** Denormalizált gyors-alias gyorsítótár (forrás: `fam_reference`; szinkron MP-3). */
     aliases = [];
+    /**
+     * Kanonikus repo-kulcs (scope-prevenció, user-FR 2026-06-22) — a stabil projekt-identitás a git-remote-ból
+     * (`org/repo`, lowercase) vagy fallback a package-névből. A SCAN stamp-eli a project-layer scope-ra a felismert
+     * git/package identitásból (`FAM_ProjectIdentity_Util.canonicalRepoKey`). Erre épül a repo-kulcs alapú
+     * duplikátum-detekció (`detectIssues.repoKeyDuplicates`), ami a KÜLÖNBÖZŐ nevű, de AZONOS repo eseteket
+     * (pl. import-`10.3.3` vs scan-`ccap-revisioned`) is elkapja — amit a puszta név-egyezés kihagy.
+     */
+    canonicalRepoKey;
     /** Leírás. */
     description;
     /** Ki hozta létre (szűkített: `manual` | `agent-write` | `import`). */
@@ -46,6 +54,7 @@ exports.famScope_dataParams = new fsm_dynamo_1.DyFM_DataModel_Params({
         canonicalName: { type: 'string', index: true, required: true },
         parentScopeId: { type: 'string', index: true },
         aliases: { type: 'string[]', index: true, default: [] },
+        canonicalRepoKey: { type: 'string', index: true },
         description: { type: 'string' },
         createdBy: { type: 'string', index: true },
     },

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

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FAM_DedupWarn_ControlService = void 0;
+const fam_vector_search_control_service_1 = require("./fam-vector-search.control-service");
+/**
+ * `FAM_DedupWarn_ControlService` (user-FR 2026-06-25) — **near-duplikátum-figyelmeztetés** íráskor: egy ÚJ entry
+ * vektorával megkeresi a tár legközelebbi szomszédait, és ha valamelyik a küszöb (`threshold`) FÖLÖTT van, jelzi
+ * (NEM blokkol — csak warning: „ez majdnem ugyanaz, mint X; érdemes lehet UPDATE-elni a meglévőt új entry helyett").
+ * A meglévő `FAM_DuplicateScan` az EGÉSZ tár O(n²) cluster-scanje (utólagos takarítás); EZ a KÖNNYŰ, ÍRÁS-IDEJŰ
+ * változat (1 vektor-keresés a friss vektorral) — a duplikáció-KELETKEZÉS megelőzésére.
+ */
+class FAM_DedupWarn_ControlService {
+    static _instance;
+    static getInstance() {
+        if (!FAM_DedupWarn_ControlService._instance) {
+            FAM_DedupWarn_ControlService._instance = new FAM_DedupWarn_ControlService();
+        }
+        return FAM_DedupWarn_ControlService._instance;
+    }
+    /**
+     * Az új tartalom (már kiszámolt `vector`) near-duplikátumai a `table` hidratált poolján: a legközelebbi `topK`
+     * szomszéd, ÖNMAGÁT (`excludeId`) kizárva, a `threshold` fölött. Üres vektor / nincs jelölt → üres lista.
+     */
+    async check(set) {
+        if (!set.vector.length) {
+            return [];
+        }
+        // +1 a topK-hoz: az önmagát (excludeId) is visszaadja score ~1.0-val, azt kiszűrjük.
+        const hits = await fam_vector_search_control_service_1.FAM_VectorSearch_ControlService.getInstance().search({
+            table: set.table,
+            queryVector: set.vector,
+            topK: (set.topK ?? 5) + 1,
+        });
+        return hits
+            .filter((hit) => hit.id !== set.excludeId && hit.score >= set.threshold)
+            .slice(0, set.topK ?? 5)
+            .map((hit) => ({ id: hit.id, score: hit.score }));
+    }
+}
+exports.FAM_DedupWarn_ControlService = FAM_DedupWarn_ControlService;

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

@@ -43,18 +43,20 @@ class FAM_DuplicateScan_ControlService {
         const registryEntry = fam_store_registry_const_1.FAM_StoreRegistry_Util.getEntry(input.table);
         const search = fam_vector_search_control_service_1.FAM_VectorSearch_ControlService.getInstance();
         const totalInPool = registryEntry ? search.getPoolSize(input.table) : 0;
+        const filtered = FAM_DuplicateScan_ControlService.hasCandidateFilter(input);
         const empty = {
             table: input.table, threshold: threshold, totalInPool: totalInPool, scanned: 0,
-            capped: false, clusterCount: 0, duplicateEntryCount: 0, clusters: [],
+            capped: false, filtered: filtered, clusterCount: 0, duplicateEntryCount: 0, clusters: [],
         };
         if (!registryEntry || !totalInPool) {
             return empty;
         }
         // 1. A (capolt) (id, vektor) halmaz lean-streamelése (NEM a teljes content — csak a vektorok).
+        // A szűrő-mezők Mongo-prefilterként MÁR ITT szűkítik a jelölt-halmazt (célzott scan a nagy táron).
         const dataService = new fam_entry_data_service_1.FAM_Entry_DataService({ dataParams: registryEntry.dataParams, issuer: this.issuer });
         const ids = [];
         const vectors = [];
-        const filter = { embeddingStatus: 'completed' };
+        const filter = FAM_DuplicateScan_ControlService.buildScanFilter(input);
         await dataService.streamHydratableVectors(filter, (id, contentVector) => {
             if (ids.length < maxEntries) {
                 ids.push(id);
@@ -62,13 +64,17 @@ class FAM_DuplicateScan_ControlService {
             }
         });
         const scanned = ids.length;
-        const capped = totalInPool > scanned;
-        // 2. Élek: minden entry top-szomszédai a küszöb felett (a saját maga kizárva). Per-entry try/catch
-        // (egy dimenzió-/embedding-anomália NE döntse az egész scan-t).
+        const capped = filtered ? scanned >= maxEntries : totalInPool > scanned;
+        // 2. Élek: minden entry top-szomszédai a küszöb felett (a saját maga kizárva). Szűrt scan-nél a
+        // találat-halmaz is a jelölt-halmazra korlátozódik (candidateIds — a cluster NE tartalmazzon
+        // szűrőn-kívüli entry-t). Per-entry try/catch (egy dimenzió-/embedding-anomália NE döntse az egész scan-t).
+        const candidateIds = filtered ? ids : undefined;
         const edges = [];
         for (let i = 0; i < scanned; i++) {
             try {
-                const hits = await search.search({ table: input.table, queryVector: vectors[i], topK: neighbors + 1 });
+                const hits = await search.search({
+                    table: input.table, queryVector: vectors[i], topK: neighbors + 1, candidateIds: candidateIds,
+                });
                 for (const hit of hits) {
                     if (hit.id !== ids[i] && hit.score >= threshold) {
                         edges.push({ a: ids[i], b: hit.id, score: hit.score });
@@ -89,19 +95,32 @@ class FAM_DuplicateScan_ControlService {
             }
         }
         const metaById = await this.fetchMeta(dataService, clusteredIds);
-        // 5. Cluster-ek építése + rendezés (legnagyobb/legtömörebb elöl) + output-cap.
+        // 5. Cluster-ek építése (tag-dúsítás + projekt-lefedettség) + a `minProjects` cross-project szűrő +
+        // rendezés (legszélesebb projekt-lefedettség, majd méret, majd score elöl) + output-cap.
+        const minProjects = input.minProjects ?? 0;
         const clusters = components
-            .map((component) => ({
-            size: component.ids.length,
-            maxScore: component.maxScore,
-            minScore: component.minScore,
-            members: component.ids.map((id) => ({
+            .map((component) => {
+            const members = component.ids.map((id) => ({
                 id: id,
                 kind: metaById.get(id)?.kind,
                 snippet: metaById.get(id)?.snippet,
-            })),
-        }))
-            .sort((left, right) => right.size - left.size || right.maxScore - left.maxScore);
+                sourceFilePath: metaById.get(id)?.sourceFilePath,
+                project: metaById.get(id)?.project,
+            }));
+            const projects = FAM_DuplicateScan_ControlService.distinctProjects(members);
+            return {
+                size: component.ids.length,
+                maxScore: component.maxScore,
+                minScore: component.minScore,
+                projects: projects,
+                projectCount: projects.length,
+                members: members,
+            };
+        })
+            .filter((cluster) => cluster.projectCount >= minProjects)
+            .sort((left, right) => right.projectCount - left.projectCount
+            || right.size - left.size
+            || right.maxScore - left.maxScore);
         const duplicateEntryCount = clusters.reduce((sum, cluster) => sum + cluster.size, 0);
         return {
             table: input.table,
@@ -109,11 +128,48 @@ class FAM_DuplicateScan_ControlService {
             totalInPool: totalInPool,
             scanned: scanned,
             capped: capped,
+            filtered: filtered,
             clusterCount: clusters.length,
             duplicateEntryCount: duplicateEntryCount,
             clusters: clusters.slice(0, maxClusters),
         };
     }
+    /** Van-e AKTÍV jelölt-szűrő az inputban (→ Mongo-prefilter + candidateIds-szűkített keresés)? Tiszta. */
+    static hasCandidateFilter(input) {
+        return Boolean(input.pathRegex || input.excludePathRegex || input.excludeRootRegex
+            || input.projects?.length || input.excludeProjects?.length);
+    }
+    /**
+     * A jelölt-halmaz Mongo-prefilterének összeállítása az input szűrő-mezőiből. Tiszta (side-effect-mentes) →
+     * unit-tesztelhető. A feltételek `$and`-be kerülnek (a `sourceFilePath` include+exclude kulcs-ütközése miatt).
+     */
+    static buildScanFilter(input) {
+        const conditions = [{ embeddingStatus: 'completed' }];
+        if (input.pathRegex) {
+            conditions.push({ sourceFilePath: { $regex: input.pathRegex, $options: 'i' } });
+        }
+        if (input.excludePathRegex) {
+            conditions.push({ sourceFilePath: { $not: { $regex: input.excludePathRegex, $options: 'i' } } });
+        }
+        if (input.excludeRootRegex) {
+            conditions.push({ 'source.root': { $not: { $regex: input.excludeRootRegex, $options: 'i' } } });
+        }
+        if (input.projects?.length) {
+            conditions.push({ scopePath: { $elemMatch: { layer: 'project', canonicalName: { $in: input.projects } } } });
+        }
+        if (input.excludeProjects?.length) {
+            conditions.push({ scopePath: { $not: { $elemMatch: { layer: 'project', canonicalName: { $in: input.excludeProjects } } } } });
+        }
+        return (conditions.length === 1 ? conditions[0] : { $and: conditions });
+    }
+    /** Egy entry projekt-neve a scopePath project-layer eleméből (nincs → undefined). Tiszta. */
+    static projectOf(scopePath) {
+        return (scopePath ?? []).find((ref) => ref.layer === 'project')?.canonicalName;
+    }
+    /** A cluster-tagok KÜLÖNBÖZŐ (nem-üres) projekt-nevei rendezve. Tiszta. */
+    static distinctProjects(members) {
+        return [...new Set(members.map((member) => member.project).filter((project) => Boolean(project)))].sort();
+    }
     /**
      * **Tiszta union-find**: a hasonlóság-élekből összefüggő komponensek (méret ≥ 2). Minden komponens id-i
      * rendezve + a komponens score-tartománya (min/max él-score). Determinista (azonos input → azonos output).
@@ -178,7 +234,7 @@ class FAM_DuplicateScan_ControlService {
         }
         return result;
     }
-    /** A clustered id-k jelleg + snippet metaadata (egy lean lekérdezés, csak a kis clustered halmazra). */
+    /** A clustered id-k jelleg + snippet + forrás-út + projekt metaadata (egy lean lekérdezés, csak a kis clustered halmazra). */
     async fetchMeta(dataService, clusteredIds) {
         const metaById = new Map();
         if (!clusteredIds.size) {
@@ -194,6 +250,8 @@ class FAM_DuplicateScan_ControlService {
             metaById.set(id, {
                 kind: entry.kind,
                 snippet: content.replace(/\s+/g, ' ').trim().slice(0, FAM_DuplicateScan_ControlService.SNIPPET_LENGTH),
+                sourceFilePath: entry.sourceFilePath,
+                project: FAM_DuplicateScan_ControlService.projectOf(entry.scopePath),
             });
         }
         return metaById;

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

@@ -3,7 +3,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.FAM_EmbeddingBootstrap_ControlService = void 0;
 const fsm_dynamo_1 = require("@futdevpro/fsm-dynamo");
 const config_control_service_1 = require("../../../_routes/server/config/config.control-service");
+const fam_hydration_coordinator_control_service_1 = require("./fam-hydration-coordinator.control-service");
 const fam_vector_search_control_service_1 = require("./fam-vector-search.control-service");
+const fam_scope_maintenance_control_service_1 = require("../../scope-reference/_services/fam-scope-maintenance.control-service");
+const fam_scan_job_control_service_1 = require("../../ingest/_services/fam-scan-job.control-service");
+const fam_memory_dormancy_control_service_1 = require("../../retrieval/_services/fam-memory-dormancy.control-service");
 /**
  * `FAM_EmbeddingBootstrap_ControlService` (SP-2.2/2.4) — az embedding + vektor-réteg **boot-hook**-ja.
  * Az `App.postProcess()` (a DB-connect + setup UTÁNI hook) hívja. Két lépés:
@@ -41,12 +45,58 @@ class FAM_EmbeddingBootstrap_ControlService {
         catch (error) {
             fsm_dynamo_1.DyFM_Log.warn(`[FAM bootstrap] ENV-config seed sikertelen: ${error?.message}`);
         }
+        // A readiness-coordinator hidratálás-bevárás time-outja a `read.hydrationWaitMs` config-ból (a hidratálás
+        // ELŐTT, hogy a `beginBoot` után érkező read-ek már a helyes időkorláttal várjanak). Best-effort (default 180s).
+        try {
+            const resolved = await config_control_service_1.FAM_Config_ControlService.getInstance().resolve('read.hydrationWaitMs');
+            if (typeof resolved.value === 'number') {
+                fam_hydration_coordinator_control_service_1.FAM_HydrationCoordinator_ControlService.getInstance().configureWaitMs(resolved.value);
+            }
+        }
+        catch (error) {
+            fsm_dynamo_1.DyFM_Log.warn(`[FAM bootstrap] hydration-wait config-feloldás sikertelen (default marad): ${error?.message}`);
+        }
         try {
             await fam_vector_search_control_service_1.FAM_VectorSearch_ControlService.getInstance().hydrateAll();
         }
         catch (error) {
             fsm_dynamo_1.DyFM_Log.warn(`[FAM bootstrap] vektor-pool hidratálás sikertelen: ${error?.message}`);
         }
+        // Scope-integritás self-check (user-FR 2026-06-22): a rendszer MAGÁTÓL ismerje fel az árva/duplikált
+        // scope-okat (boot után, best-effort — a takarítás `merge_scopes`, nem itt). Csak figyelmeztet, nem ír.
+        try {
+            const issues = await fam_scope_maintenance_control_service_1.FAM_ScopeMaintenance_ControlService.getInstance().detectIssues();
+            if (issues.hasIssues) {
+                fsm_dynamo_1.DyFM_Log.warn(`[FAM bootstrap] SCOPE-INTEGRITÁS: ${issues.orphanProjectScopes.length} árva projekt-scope + `
+                    + `${issues.duplicateScopes.length} duplikált (name+layer) — futtasd a 'detect_scope_issues' capability-t `
+                    + 'a részletekért, a takarítás a merge_scopes-szal.');
+            }
+        }
+        catch (error) {
+            fsm_dynamo_1.DyFM_Log.warn(`[FAM bootstrap] scope-integritás self-check sikertelen: ${error?.message}`);
+        }
+        // AUTO-RESUME (FEAT-008 Phase 4, user-FR 2026-06-22): a megszakadt (running/pending) scan-job-okat folytatjuk
+        // a megszakítási ponttól (durable Mongo-állapot → a már kész projektek átugorva). Best-effort, a boot UTÁN.
+        try {
+            const resumed = await fam_scan_job_control_service_1.FAM_ScanJob_ControlService.getInstance().resumeInterrupted();
+            if (resumed > 0) {
+                fsm_dynamo_1.DyFM_Log.info(`[FAM bootstrap] ${resumed} megszakadt scan-job FOLYTATVA a durable állapotból.`);
+            }
+        }
+        catch (error) {
+            fsm_dynamo_1.DyFM_Log.warn(`[FAM bootstrap] scan-job auto-resume sikertelen: ${error?.message}`);
+        }
+        // MEMORY DORMANCY sweep (dsgn-013 §5, MAM F3): a régóta-nem-felidézett, ritkán-használt memóriák ALVÓ-vá
+        // jelölése (a hatás a KÖVETKEZŐ re-hidratáláskor jön; a hot pool kisebb marad). Best-effort, a boot UTÁN.
+        try {
+            const sweep = await fam_memory_dormancy_control_service_1.FAM_MemoryDormancy_ControlService.getInstance().sweep(Date.now());
+            if (sweep.markedDormant > 0) {
+                fsm_dynamo_1.DyFM_Log.info(`[FAM bootstrap] memory-dormancy: ${sweep.markedDormant} bejegyzés ALVÓ-vá jelölve.`);
+            }
+        }
+        catch (error) {
+            fsm_dynamo_1.DyFM_Log.warn(`[FAM bootstrap] memory-dormancy sweep sikertelen: ${error?.message}`);
+        }
     }
 }
 exports.FAM_EmbeddingBootstrap_ControlService = FAM_EmbeddingBootstrap_ControlService;

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

@@ -52,7 +52,7 @@ class FAM_EmbeddingPipeline_ControlService {
     async embedAndPersist(set) {
         const registryEntry = fam_store_registry_const_1.FAM_StoreRegistry_Util.getEntry(set.table);
         if (!registryEntry || !set.entry._id) {
-            return { status: 'error', dims: 0 };
+            return { status: 'error', dims: 0, vector: [] };
         }
         const dataService = new fam_entry_data_service_1.FAM_Entry_DataService({ dataParams: registryEntry.dataParams, issuer: this.issuer });
         // FEAT-003: a tartalomban felismert azonosító-kódok inverted-index-be írása — az embed-sikertől
@@ -67,7 +67,7 @@ class FAM_EmbeddingPipeline_ControlService {
         if (!composed.trim().length) {
             // Nincs vektorizálható content → marad pending (a write-validáció a content-kötelezőséget
             // külön kezeli; itt csak jelezzük, hogy nincs mit embeddelni).
-            return { status: 'error', dims: 0 };
+            return { status: 'error', dims: 0, vector: [] };
         }
         try {
             const vectors = await fam_embedding_control_service_1.FAM_Embedding_ControlService.getInstance().embedTexts({
@@ -89,21 +89,47 @@ class FAM_EmbeddingPipeline_ControlService {
                 contentHash: contentHash,
             });
             fam_vector_search_control_service_1.FAM_VectorSearch_ControlService.getInstance().upsertVector({ table: set.table, id: set.entry._id, vector: vector });
-            return { status: 'completed', dims: vector.length };
+            return { status: 'completed', dims: vector.length, vector: vector };
         }
         catch (error) {
             // No-silent-failure: az entry `error`-státuszba kerül + a hiba persistált; a pool-ból kivesszük.
             await dataService.setEmbeddingStatus(set.entry._id, 'error');
             fam_vector_search_control_service_1.FAM_VectorSearch_ControlService.getInstance().removeVector(set.table, set.entry._id);
+            // A belső provider-hiba (`FAM-EMB-PROVIDER-002`) DIAGNOSZTIKÁJÁT (a vétkes batch csonkolt MINTÁJA +
+            // provider) FELEMELJÜK a persistált rekord TOP-LEVEL contextSnapshot-jába (user-FR 2026-06-24 — „az LM
+            // Studio által dobott hibákat el kéne tároljuk … bizonyos sémákon akad fönn újra"). Különben a
+            // `failedSample` csak a cause-láncon élne, nem a kereshető rekord-mezőben.
+            const diag = FAM_EmbeddingPipeline_ControlService.extractProviderDiagnostics(error);
             await errors_control_service_1.FAM_Error_ControlService.getInstance().emit({
                 errorCode: error_codes_const_1.FAM_ERROR_CODES.embProviderUnreachable,
                 message: `Az entry embeddelése sikertelen (table='${set.table}', id='${set.entry._id}').`,
                 cause: error,
-                context: { operation: 'embed-and-persist', table: set.table },
+                context: {
+                    operation: 'embed-and-persist', table: set.table,
+                    provider: diag.provider, failedSample: diag.failedSample,
+                },
             });
-            return { status: 'error', dims: 0 };
+            return { status: 'error', dims: 0, vector: [] };
         }
     }
+    /**
+     * A belső `FAM-EMB-PROVIDER-002` (vagy bármely FAM-error) cause `contextSnapshot`-jából kiolvassa a
+     * diagnosztikát (a vétkes batch `failedSample`-jét + a `provider`-t), hogy az embed-and-persist rekord
+     * TOP-LEVEL kontextusába felemelhető legyen (kereshető, redaktált). Fail-safe: bármi hiányzik → üres.
+     */
+    static extractProviderDiagnostics(error) {
+        const additional = error?.additionalContent;
+        const snapshot = additional?.contextSnapshot;
+        if (!snapshot || typeof snapshot !== 'object') {
+            return {};
+        }
+        const sample = snapshot.failedSample;
+        const provider = snapshot.provider;
+        return {
+            failedSample: typeof sample === 'string' ? sample : undefined,
+            provider: typeof provider === 'string' ? provider : undefined,
+        };
+    }
     // =========================================================================
     // RE-EMBED (dsgn-006 §5) — modell-/provider-váltás
     // =========================================================================

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

@@ -4,6 +4,7 @@ exports.FAM_Embedding_ControlService = void 0;
 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 fam_retry_util_1 = require("../../../_collections/fam-retry.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");
@@ -27,6 +28,8 @@ class FAM_Embedding_ControlService {
     static _instance;
     /** Default issuer (a hibák / cost-event issuer-éhez). */
     issuer = 'FAM_Embedding_ControlService';
+    /** A provider-hívás max próbálkozás-száma tranziens hibára (1 = nincs retry; env `FAM_EMBED_MAX_ATTEMPTS`, default 3). */
+    providerMaxAttempts = Math.max(1, Number(process.env.FAM_EMBED_MAX_ATTEMPTS) || 3);
     static getInstance() {
         if (!FAM_Embedding_ControlService._instance) {
             FAM_Embedding_ControlService._instance = new FAM_Embedding_ControlService();
@@ -106,14 +109,22 @@ class FAM_Embedding_ControlService {
         const allVectors = [];
         for (let i = 0; i < texts.length; i += resolved.batchSize) {
             const batch = texts.slice(i, i + resolved.batchSize);
+            let vectors;
             try {
-                const vectors = await provider.embedTexts({ texts: batch, model: resolved.modelId, issuer: issuer });
-                this.assertDimensions(vectors, resolved, issuer);
-                allVectors.push(...vectors);
+                // RETRY a TRANZIENS provider-hibára (stresszteszt-lelet 2026-06-22: konkurrens terhelés alatt a remote
+                // LM Studio embedding ritkán `FAM-EMB-PROVIDER-002`-t adott → a teljes read elbukott). Backoff-fal
+                // újrapróbáljuk; a query- ÉS write-embed is profitál (egy scan-chunk se vesszen el egy tranziens hibán).
+                vectors = await this.embedBatchWithRetry(provider, batch, resolved.modelId, issuer);
             }
             catch (error) {
-                throw this.providerError(resolved.provider, resolved.modelId, error, issuer);
+                // A VÉTKES batch-et (`batch`) + a scope/table-kontextust átadjuk a hiba-factory-nak: így a tárolt
+                // `FAM-EMB-PROVIDER-002` rekord hordozza, MELY tartalom/séma omlasztotta a modellt (user-FR 2026-06-24).
+                throw this.providerError(resolved.provider, resolved.modelId, error, issuer, {
+                    batch: batch, table: set.table, scopePath: set.scopePath,
+                });
             }
+            this.assertDimensions(vectors, resolved, issuer);
+            allVectors.push(...vectors);
         }
         // Cost-aggregálás (SP-2.4, BFR-AM-007): a becsült tokenből (a pontos cost-event a bedrock-szinten).
         fam_embedding_cost_control_service_1.FAM_EmbeddingCost_ControlService.getInstance().recordActual({
@@ -170,7 +181,7 @@ class FAM_Embedding_ControlService {
                         context: { operation: 'build-provider', provider: 'lmstudio' },
                     });
                 }
-                return new fam_lmstudio_embedding_provider_1.FAM_LMStudio_EmbeddingProvider(resolved.baseUrl, this.lmStudioApiKey());
+                return new fam_lmstudio_embedding_provider_1.FAM_LMStudio_EmbeddingProvider(resolved.baseUrl, this.lmStudioApiKey(), this.lmStudioTimeoutMs());
             case 'mock':
                 return new fam_mock_embedding_provider_1.FAM_Mock_EmbeddingProvider(resolved.dims ?? undefined);
             default:
@@ -203,20 +214,133 @@ class FAM_Embedding_ControlService {
             });
         }
     }
-    /** Provider-hiba kanonikus `FAM-EMB-PROVIDER-002`-vé (elérhetetlen / API-hiba). */
-    providerError(provider, modelId, cause, issuer) {
+    /**
+     * Egy batch embeddelése RETRY-jal a TRANZIENS provider-hibára (stresszteszt-lelet 2026-06-22). A `providerMaxAttempts`
+     * próbálkozás, exponenciális backoff-fal (250ms × 2^n, max ~1s); a `FAM_Error` (kanonikus, pl. dimenzió-mismatch) NEM
+     * retry-zhető (az determinisztikus hiba). Az utolsó hibát továbbdobja (a hívó `providerError`-rá konvertálja).
+     */
+    async embedBatchWithRetry(provider, batch, modelId, issuer) {
+        return fam_retry_util_1.FAM_Retry_Util.withRetry(() => provider.embedTexts({ texts: batch, model: modelId, issuer: issuer }), {
+            maxAttempts: this.providerMaxAttempts,
+            // Kanonikus FAM-hiba (pl. dimenzió-mismatch) = determinisztikus → NEM retry-zhető; minden más tranziens.
+            isRetryable: (error) => !(error instanceof fsm_dynamo_1.DyFM_Error),
+            onRetry: (attempt, backoffMs, error) => fsm_dynamo_1.DyFM_Log.warn(`[FAM embedding] provider-hiba (${attempt}/${this.providerMaxAttempts}. próba) — `
+                + `${backoffMs}ms múlva újra: ${error?.message}`),
+        });
+    }
+    /**
+     * Provider-hiba kanonikus `FAM-EMB-PROVIDER-002`-vé (elérhetetlen / API-hiba). A `failed` (a vétkes batch +
+     * scope/table) opcionális: ha van, a hiba diagnosztizálhatóvá válik (user-FR 2026-06-24 — „bizonyos sémákon akad
+     * fönn újra és újra az LM Studio"). A batch SÉMA-SIGNATURE-ja az ÜZENETBE kerül (így a DyFM dedup séma-szerint
+     * csoportosít: ugyanaz a tartalom-forma → ugyanaz a rekord, occurrence++; ELTÉRŐ forma → külön rekord), a
+     * csonkolt MINTA pedig a `context.failedSample`-be (a tényleges tartalom szemrevételezéséhez).
+     */
+    providerError(provider, modelId, cause, issuer, failed) {
         // Ha már kanonikus FAM error (pl. dimenzió-mismatch a batch-en belül), nem csomagoljuk újra.
         if (cause instanceof fsm_dynamo_1.DyFM_Error) {
             return cause;
         }
+        const described = failed?.batch?.length ? this.describeFailedBatch(failed.batch) : undefined;
+        const signatureSuffix = described ? ` ${described.signature}` : '';
         return fam_error_factory_util_1.FAM_Error_Util.create({
             errorCode: error_codes_const_1.FAM_ERROR_CODES.embProviderUnreachable,
-            message: `Az embedding-provider ('${provider}', modell '${modelId}') elérhetetlen vagy hibát adott.`,
+            message: `Az embedding-provider ('${provider}', modell '${modelId}') elérhetetlen vagy hibát adott.${signatureSuffix}`,
             issuer: issuer,
             cause: cause,
-            context: { operation: 'embed', provider: provider },
+            context: {
+                operation: 'embed',
+                provider: provider,
+                table: failed?.table ?? null,
+                scopePath: failed?.scopePath?.map((ref) => ref.canonicalName) ?? null,
+                failedSample: described?.sample ?? null,
+            },
         });
     }
+    /**
+     * A vétkes embedding-batch DIAGNOSZTIKAI leírása (user-FR 2026-06-24). Két részt ad:
+     * - `signature`: KOMPAKT, determinisztikus séma-jelző (batch-darabszám + a leghosszabb szöveg HOSSZ-vödre +
+     *   tartalom-fajta heurisztika + non-ASCII arány-vödör) — ez az ÜZENETBE megy, hogy a dedup séma-szerint
+     *   csoportosítson (azonos forma → 1 rekord/occurrence++; eltérő forma → külön rekord).
+     * - `sample`: a leghosszabb néhány szöveg HOSSZ-korlátozott, összefűzött mintája — a context `failedSample`-jébe
+     *   (a tényleges, modell-omlasztó tartalom szemrevételezéséhez). A sensitive-redakciót a context-util végzi.
+     */
+    describeFailedBatch(batch) {
+        const lengths = batch.map((text) => text.length);
+        const maxLen = lengths.reduce((max, len) => (len > max ? len : max), 0);
+        // A leghosszabb szövegen futtatjuk a fajta-/non-ASCII-heurisztikát (ez a legvalószínűbb omlasztó).
+        const longest = batch.reduce((acc, text) => (text.length > acc.length ? text : acc), '');
+        const kind = this.classifyContentKind(longest);
+        const nonAsciiBucket = this.nonAsciiBucket(longest);
+        const signature = `[batch n=${batch.length}, maxLen=${this.lengthBucket(maxLen)}, `
+            + `kind=${kind}, nonAscii=${nonAsciiBucket}]`;
+        // Minta: a 2 leghosszabb szöveg, egyenként ~400 karakterre csonkolva (a teljes minta-cap ~1000 karakter).
+        const sorted = [...batch].sort((a, b) => b.length - a.length).slice(0, 2);
+        const sample = sorted
+            .map((text, index) => `#${index + 1} (len=${text.length}): ${this.truncate(text, 450)}`)
+            .join('\n---\n')
+            .slice(0, 1000);
+        return { signature: signature, sample: sample };
+    }
+    /** Hossz-vödör (a maxLen kompakt, dedup-barát kvantálása — ne fragmentáljon karakter-pontosan). */
+    lengthBucket(length) {
+        if (length < 512) {
+            return '<512';
+        }
+        if (length < 2048) {
+            return '512-2k';
+        }
+        if (length < 8192) {
+            return '2k-8k';
+        }
+        if (length < 32768) {
+            return '8k-32k';
+        }
+        return '>32k';
+    }
+    /** Tartalom-fajta heurisztika (json/code/markdown/prose) — a leghosszabb szöveg mintájából. */
+    classifyContentKind(text) {
+        const head = text.slice(0, 4096);
+        const trimmed = head.trimStart();
+        if ((trimmed.startsWith('{') || trimmed.startsWith('[')) && /"\s*:/.test(head)) {
+            return 'json-like';
+        }
+        if (/```|(^|\n)\s*(import |export |function |const |class |def |public |private )/.test(head)) {
+            return 'code-like';
+        }
+        if (/(^|\n)(#{1,6} |[-*] |\d+\. |> )/.test(head)) {
+            return 'markdown';
+        }
+        return 'prose';
+    }
+    /** Non-ASCII arány-vödör (low/med/high) — a >127 kódpontú karakterek hányada a minta-fejen. */
+    nonAsciiBucket(text) {
+        const head = text.slice(0, 4096);
+        if (!head.length) {
+            return 'none';
+        }
+        let nonAscii = 0;
+        for (let i = 0; i < head.length; i++) {
+            if (head.charCodeAt(i) > 127) {
+                nonAscii++;
+            }
+        }
+        const ratio = nonAscii / head.length;
+        if (!nonAscii) {
+            return 'none';
+        }
+        if (ratio < 0.05) {
+            return 'low';
+        }
+        if (ratio < 0.2) {
+            return 'med';
+        }
+        return 'high';
+    }
+    /** Egy-soros, hossz-korlátozott csonkolás (a newline-okat szóközre cseréli a kompakt minta-sorhoz). */
+    truncate(text, max) {
+        const oneLine = text.replace(/\s+/g, ' ').trim();
+        return oneLine.length > max ? `${oneLine.slice(0, max)}…` : oneLine;
+    }
     /** Cost-cap blokk → `FAM-EMB-COSTCAP-001` (block-before-overrun; dsgn-006 §7 / dsgn-008). */
     costCapError(reason, issuer) {
         return fam_error_factory_util_1.FAM_Error_Util.create({
@@ -259,6 +383,15 @@ class FAM_Embedding_ControlService {
     lmStudioApiKey() {
         return process.env.LMSTUDIO_API_KEY;
     }
+    /**
+     * Az LM Studio request-timeout (ms) az ENV-ből (`LMSTUDIO_REQUEST_TIMEOUT_MS`, default 120000 = 2 perc). Egy
+     * NEM-VÁLASZOLÓ LM Studio (crash-elt modell) ne fagyassza be a teljes scant — a timeout retry-zható hibára fordul.
+     * `0` → nincs timeout (a régi viselkedés). Érvénytelen/hiányzó env → a 2 perces default.
+     */
+    lmStudioTimeoutMs() {
+        const raw = Number(process.env.LMSTUDIO_REQUEST_TIMEOUT_MS);
+        return Number.isFinite(raw) && raw >= 0 ? raw : 120000;
+    }
     /** A `embedOne` set-jéből a `text`-et kihagyó opció-objektum (a `embedTexts`-nek átadva). */
     stripText(set) {
         return {

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

@@ -124,6 +124,15 @@ class FAM_Entry_DataService extends nts_dynamo_1.DyNTS_DataService {
         const update = { $set: { embeddingStatus: status } };
         await this.updateData({ filterBy: { _id: id }, update: update });
     }
+    /**
+     * A `superseded` (LEVÁLTOTT) flag atomikus beállítása (dsgn-013 §6, MAM F4) — egy additív (`memory`) fájl régi,
+     * már átírt tartalmát jelöli leváltottnak. NEM törlés (a tartalom + vektor megmarad, cold-kereshető); a ranking
+     * penalizálja. Az embed-pipeline-tól FÜGGETLEN flag-frissítés.
+     */
+    async setSuperseded(id, superseded) {
+        const update = { $set: { superseded: superseded } };
+        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