@futdevpro/fdp-agent-memory 1.1.30 → 1.1.113

package/build/src/_modules/scope-reference/_services/fam-scope-maintenance.control-service.js

@@ -79,6 +79,20 @@ class FAM_ScopeMaintenance_ControlService {
         const dryRun = set.dryRun !== false;
         const intoRef = { scopeId: intoId, layer: into.layer ?? '', canonicalName: into.canonicalName ?? '' };
         const affected = await this.countAffected(fromId);
+        // MERGE-GUARD (2026-06-24 fix): külön projekt-gyökerek (`source.root`) → gyaníthatóan KÜLÖN projektek →
+        // BLOKK (force nélkül). Ez fogja meg a téves repoKey-duplikátum-merge-et (a `ccap-revisioned`→`ccap-speech-
+        // recognition` típusú szennyezést), MIELŐTT 50k fájl átkeveredne. A `force:true` (tudatos user-akció) felülírja.
+        const blockedReason = set.force
+            ? undefined
+            : await this.crossProjectMergeBlock(fromId, intoId, from.canonicalName ?? '', into.canonicalName ?? '');
+        if (blockedReason) {
+            return {
+                operation: 'merge_scopes', dryRun: dryRun, blockedReason: blockedReason,
+                from: { scopeId: fromId, layer: from.layer ?? '', canonicalName: from.canonicalName ?? '' },
+                into: intoRef, affected: affected, totalAffected: affected.reduce((s, i) => s + i.count, 0),
+                fromScopeDeleted: false,
+            };
+        }
         if (!dryRun) {
             const entryUpdate = fam_scope_maintenance_util_1.FAM_ScopeMaintenance_Util.mergeEntryUpdate(fromId, intoRef);
             await this.applyEntryUpdate(entryUpdate);
@@ -97,13 +111,232 @@ class FAM_ScopeMaintenance_ControlService {
             fromScopeDeleted: !dryRun,
         };
     }
+    /**
+     * Egy scope SCAN-eredetű entry-jeinek soft-delete-je (RECOVERY egy félre-routolt scan után, user-FR 2026-06-24).
+     * A `sourceType` default `'scan'` → a manuális/agent/import-SZERZETT (pótolhatatlan) tartalmat SOHA nem törli.
+     * Az opcionális `sourceRootContains` a `source.root`-ot szűri (sebészi cross-root takarítás: pl. a `ccap-revisioned`
+     * gyökerű szennyezés a `ccap-client` scope-ból, a `ccap` saját entry-jeinek megtartásával). `dryRun` (DEFAULT true)
+     * → csak a per-collection szám + a `rootSamples` (verifikáció: jó scope-ot/gyökeret törlünk-e), NEM ír. A tényleges
+     * (soft-delete + LVS-pool-kivétel) az explicit `dryRun:false`. A scan-tartalom ÚJRA-SZKENNELHETŐ → nem destruktív-végleges.
+     */
+    async resetScope(set) {
+        const scope = await this.resolveScope(set);
+        const scopeId = scope._id;
+        const dryRun = set.dryRun !== false;
+        const sourceType = (set.sourceType ?? 'scan').trim();
+        const sourceRootContains = (set.sourceRootContains ?? '').trim() || undefined;
+        const tableName = (set.table ?? '').trim() || undefined;
+        const filter = {
+            ...fam_scope_maintenance_util_1.FAM_ScopeMaintenance_Util.buildResetFilter({ scopeId: scopeId, sourceType: sourceType, sourceRootContains: sourceRootContains }),
+            _deleted: null, // csak az AKTÍV (nem már soft-deleted) entry-ket (a `_deleted` Date-mező; `null` = aktív/hiányzó).
+        };
+        const targets = tableName
+            ? (embedding_1.FAM_StoreRegistry_Util.getEntry(tableName) ? [embedding_1.FAM_StoreRegistry_Util.getEntry(tableName)] : [])
+            : embedding_1.FAM_STORE_REGISTRY;
+        const affected = [];
+        const rootSamples = new Set();
+        let totalAffected = 0;
+        for (const registryEntry of targets) {
+            // A példányosítás regisztrálja a modellt → a valós collection (a raw find a soft-delete-szemantikát explicit kezeli).
+            new embedding_1.FAM_Entry_DataService({ dataParams: registryEntry.dataParams, issuer: this.issuer });
+            const collection = mongoose_1.default.models[registryEntry.dataParams.dataName]?.collection;
+            if (!collection) {
+                continue;
+            }
+            const matched = await collection.find(filter, { projection: { 'source.root': 1 } }).toArray();
+            for (const entry of matched) {
+                const root = entry.source?.root;
+                if (root && rootSamples.size < 8) {
+                    rootSamples.add(root);
+                }
+            }
+            if (!dryRun && matched.length) {
+                // BULK soft-delete (DIREKT `_deleted` — NEM `deleteData`): a FAM entry-tárak `addArchive:true`-ok, így a
+                // per-entry `deleteData` minden törölt entry-ből ARCHÍV-másolatot készítene (bloat + lassú 59k-ra). A reset
+                // DISCARD (nem archive) → közvetlen `_deleted` (Date), amit a `_deleted: null` aktív-szűrő kizár; a hívás
+                // utáni restart tiszta (a soft-deletedek nélküli) poolt hidratál. A live pool-coherence: in-memory removeVector.
+                await collection.updateMany(filter, { $set: { _deleted: new Date() } });
+                for (const entry of matched) {
+                    embedding_1.FAM_VectorSearch_ControlService.getInstance().removeVector(registryEntry.table, String(entry._id));
+                }
+            }
+            affected.push({ collection: collection.collectionName, count: matched.length });
+            totalAffected += matched.length;
+        }
+        return {
+            operation: 'reset_scope',
+            dryRun: dryRun,
+            scope: { scopeId: scopeId, layer: scope.layer ?? '', canonicalName: scope.canonicalName ?? '' },
+            sourceType: sourceType,
+            sourceRootContains: sourceRootContains,
+            tableFilter: tableName,
+            affected: affected,
+            totalAffected: totalAffected,
+            rootSamples: [...rootSamples],
+        };
+    }
     /** Az `entryUpdate` spec alkalmazása MINDEN fő RAG-tár collection-jén (mongoose `updateMany` + arrayFilters). */
     async applyEntryUpdate(entryUpdate) {
         for (const named of this.entryCollections()) {
             await named.collection.updateMany(entryUpdate.filter, entryUpdate.update, { arrayFilters: entryUpdate.arrayFilters });
         }
     }
+    /** Egy scope entry-jeinek DISTINCT `source.root` halmaza minden fő tárban (a merge-guard bemenete). Normalizált (lowercase, `/`). */
+    async distinctRootsForScope(scopeId) {
+        const roots = new Set();
+        for (const named of this.entryCollections()) {
+            const values = await named.collection.distinct('source.root', { 'scopePath.scopeId': scopeId, _deleted: { $ne: true } });
+            for (const value of values) {
+                if (typeof value === 'string' && value.trim()) {
+                    roots.add(value.trim().toLowerCase().replace(/\\/g, '/'));
+                }
+            }
+        }
+        return roots;
+    }
+    /**
+     * MERGE-GUARD mag (2026-06-24 fix): blokk-ok-szöveg, ha a `from` és az `into` scope entry-jei KÜLÖNBÖZŐ (disjunkt)
+     * projekt-gyökerekből származnak — vagyis a merge KÜLÖN projekteket keverne. `undefined` (engedélyezve), ha bármelyik
+     * oldalon NINCS root-infó (manuális/importált entry — nem dönthető el), VAGY ha van KÖZÖS gyökér (ugyanaz a projekt,
+     * pl. átnevezés-merge legit). Ez fogja meg a téves repoKey-duplikátum-merge-et a tartalom-átkeveredés ELŐTT.
+     */
+    async crossProjectMergeBlock(fromId, intoId, fromName, intoName) {
+        const [fromRoots, intoRoots] = await Promise.all([this.distinctRootsForScope(fromId), this.distinctRootsForScope(intoId)]);
+        if (!fromRoots.size || !intoRoots.size) {
+            return undefined; // nincs root-infó → nem blokkolunk (nem dönthető el biztosan)
+        }
+        const overlap = [...fromRoots].some((root) => intoRoots.has(root));
+        if (overlap) {
+            return undefined; // van közös projekt-gyökér → ugyanaz a projekt (legit merge)
+        }
+        const sample = (set) => [...set].slice(0, 3).join(', ');
+        return `A(z) '${fromName}' és '${intoName}' scope entry-jei KÜLÖNBÖZŐ projekt-gyökerekből származnak `
+            + `(from: ${sample(fromRoots)} | into: ${sample(intoRoots)}) — gyaníthatóan KÜLÖN projektek, a merge `
+            + `összekeverné a tartalmukat. Blokkolva (a téves repoKey-duplikátum-szennyezés ellen). `
+            + `Ha tényleg össze akarod olvasztani: force:true.`;
+    }
     /** A `scopeId`-t hivatkozó aktív entry-k száma per-collection (a 6 fő tár + a reference). */
+    /**
+     * Scope-integritás SELF-CHECK (user-FR 2026-06-22 — a rendszer ismerje fel magától a problémás scope-okat):
+     * (a) **árva projekt-scope** (`layer='project'`, de nincs `parentScopeId` — tipikusan import-eredetű lapos scope,
+     * a scan org-parented párja mellett), (b) **duplikátum** (ugyanaz a `(canonicalName, layer)` többször). Mindkettőhöz
+     * az entry-számot is adja (a merge-döntéshez: a parented/nagyobb az `into`). Csak OLVAS — a takarítás `merge_scopes`.
+     */
+    async detectIssues() {
+        const scopes = await this.scopeCollection().collection
+            .find({}, { projection: { canonicalName: 1, layer: 1, parentScopeId: 1, canonicalRepoKey: 1 } })
+            .toArray();
+        // Az entry-számokat EGYSZER számoljuk minden érintett scope-ra (a 3 csoport megosztja — nincs dupla countDocuments).
+        const entryCountCache = new Map();
+        const countFor = async (scopeId) => {
+            if (!entryCountCache.has(scopeId)) {
+                entryCountCache.set(scopeId, await this.totalEntryCount(scopeId));
+            }
+            return entryCountCache.get(scopeId);
+        };
+        const orphanProjectScopes = [];
+        const byNameKey = new Map();
+        const byRepoKey = new Map();
+        const pushTo = (map, key, scope) => {
+            const bucket = map.get(key) ?? [];
+            bucket.push(scope);
+            map.set(key, bucket);
+        };
+        for (const scope of scopes) {
+            pushTo(byNameKey, `${scope.layer ?? ''}|${scope.canonicalName ?? ''}`, scope);
+            const repoKey = (scope.canonicalRepoKey ?? '').trim().toLowerCase();
+            if (repoKey) {
+                pushTo(byRepoKey, repoKey, scope);
+            }
+            if (scope.layer === 'project' && !scope.parentScopeId) {
+                orphanProjectScopes.push({
+                    scopeId: String(scope._id), canonicalName: scope.canonicalName ?? '',
+                    entryCount: await countFor(String(scope._id)),
+                });
+            }
+        }
+        const toMember = async (scope) => ({
+            scopeId: String(scope._id), parentScopeId: scope.parentScopeId,
+            canonicalName: scope.canonicalName ?? '', canonicalRepoKey: scope.canonicalRepoKey,
+            entryCount: await countFor(String(scope._id)),
+        });
+        const duplicateScopes = [];
+        for (const [, group] of byNameKey) {
+            if (group.length <= 1) {
+                continue;
+            }
+            const members = [];
+            for (const scope of group) {
+                members.push(await toMember(scope));
+            }
+            duplicateScopes.push({ canonicalName: group[0].canonicalName ?? '', layer: group[0].layer ?? '', members: members });
+        }
+        const repoKeyDuplicates = [];
+        for (const [repoKey, group] of byRepoKey) {
+            // Egyedi scopeId-k (ugyanaz a scope ne számítson kétszer); ≥2 KÜLÖNBÖZŐ scope = repo-kulcs-duplikátum.
+            const uniqueIds = new Set(group.map((scope) => String(scope._id)));
+            if (uniqueIds.size <= 1) {
+                continue;
+            }
+            const members = [];
+            for (const scope of group) {
+                members.push(await toMember(scope));
+            }
+            repoKeyDuplicates.push({ canonicalRepoKey: repoKey, members: members });
+        }
+        return {
+            scopesScanned: scopes.length,
+            orphanProjectScopes: orphanProjectScopes,
+            duplicateScopes: duplicateScopes,
+            repoKeyDuplicates: repoKeyDuplicates,
+            hasIssues: orphanProjectScopes.length > 0 || duplicateScopes.length > 0 || repoKeyDuplicates.length > 0,
+        };
+    }
+    /**
+     * `suggestMerges()` (scope-prevenció, user-FR 2026-06-22) — a `detectIssues` által felismert duplikátumokból
+     * KONKRÉT, futtatható `merge_scopes from→into` direktívák (pure `buildMergeSuggestions`). A repo-kulcs-csoportok
+     * elsőbbséget élveznek (a legbiztosabb identitás), az `into` a parented/legtöbb-entry-jű scope. NEM mutál — a
+     * tényleges összeolvasztás a `mergeScopes` (dryRun-default). Ez teszi az auto-felismerést AKCIONÁLHATÓVÁ.
+     */
+    async suggestMerges() {
+        const report = await this.detectIssues();
+        const groups = [
+            ...report.repoKeyDuplicates.map((duplicate) => ({
+                groupKind: 'repo-key', key: duplicate.canonicalRepoKey,
+                members: duplicate.members.map((member) => this.toMergeMember(member)),
+            })),
+            ...report.duplicateScopes.map((duplicate) => ({
+                groupKind: 'name', key: `${duplicate.layer}|${duplicate.canonicalName}`,
+                members: duplicate.members.map((member) => this.toMergeMember(member, duplicate.canonicalName, duplicate.layer)),
+            })),
+        ];
+        return { suggestions: fam_scope_maintenance_util_1.FAM_ScopeMaintenance_Util.buildMergeSuggestions(groups), report: report };
+    }
+    /** Egy issue-member → merge-member (a name-csoportban a közös név/layer pótlása, ha a member nem hordozza). */
+    toMergeMember(member, fallbackName, layer) {
+        return {
+            scopeId: member.scopeId,
+            canonicalName: member.canonicalName ?? fallbackName ?? '',
+            layer: layer,
+            parentScopeId: member.parentScopeId,
+            entryCount: member.entryCount,
+            canonicalRepoKey: member.canonicalRepoKey,
+        };
+    }
+    /** Egy scope összes entry-száma a 6 fő tárban (a detekció merge-súlyozásához). */
+    async totalEntryCount(scopeId) {
+        let total = 0;
+        for (const named of this.entryCollections()) {
+            total += await named.collection.countDocuments({ 'scopePath.scopeId': scopeId });
+        }
+        return total;
+    }
+    /** A `fam_scopes` mongoose-collection-je (a DS-példányosítás regisztrálja a modellt). */
+    scopeCollection() {
+        new fam_scope_data_service_1.FAM_Scope_DataService({ issuer: this.issuer });
+        const model = mongoose_1.default.models['fam_scopes'];
+        return { name: model?.collection?.collectionName ?? 'fam_scopes', collection: model.collection };
+    }
     async countAffected(scopeId) {
         const affected = [];
         for (const named of this.entryCollections()) {

package/build/src/_modules/scope-reference/_services/fam-scope.data-service.js

@@ -211,5 +211,30 @@ class FAM_Scope_DataService extends nts_dynamo_1.DyNTS_DataService {
     async setAliases(scopeId, aliases) {
         await this.updateData({ filterBy: { _id: scopeId }, update: { $set: { aliases: aliases } } });
     }
+    /**
+     * A scope `canonicalRepoKey` stamp-elése (scope-prevenció, user-FR 2026-06-22; `$set`, atomikus). A SCAN
+     * hívja a project-layer scope-ra a felismert git/package identitásból — erre épül a repo-kulcs alapú
+     * duplikátum-detekció. Csak nem-üres kulcsot ír; idempotens (ugyanaz a kulcs újraírása no-op-szerű).
+     */
+    async setCanonicalRepoKey(scopeId, canonicalRepoKey) {
+        const key = (canonicalRepoKey ?? '').trim();
+        if (!scopeId || !key) {
+            return;
+        }
+        await this.updateData({ filterBy: { _id: scopeId }, update: { $set: { canonicalRepoKey: key } } });
+    }
+    /**
+     * `findByRepoKey(canonicalRepoKey)` (scope-prevenció) — egy kanonikus repo-kulcsra illeszkedő összes aktív
+     * scope (case-insensitive trim-egyezés). ≥2 találat = repo-kulcs-duplikátum (a `detectIssues` merge-jelölt).
+     * A halmaz kicsi → in-memory szűrés.
+     */
+    async findByRepoKey(canonicalRepoKey) {
+        const target = (canonicalRepoKey ?? '').trim().toLowerCase();
+        if (!target) {
+            return [];
+        }
+        const all = await this.findAllActive();
+        return all.filter((scope) => (scope.canonicalRepoKey ?? '').trim().toLowerCase() === target);
+    }
 }
 exports.FAM_Scope_DataService = FAM_Scope_DataService;

package/build/src/_routes/server/api/api.controller.js

@@ -9,10 +9,18 @@ const nts_dynamo_2 = require("@futdevpro/nts-dynamo");
 const fam_version_const_1 = require("../../../_collections/fam-version.const");
 const fam_table_type_enum_1 = require("../../../_enums/fam-table.type-enum");
 const fam_config_level_type_enum_1 = require("../../../_enums/fam-config-level.type-enum");
+const fam_operation_queue_service_1 = require("../../../_collections/fam-operation-queue.service");
+const fam_scan_job_control_service_1 = require("../../../_modules/ingest/_services/fam-scan-job.control-service");
+const fam_vector_search_control_service_1 = require("../../../_modules/embedding/_services/fam-vector-search.control-service");
 const config_control_service_1 = require("../config/config.control-service");
+const errors_control_service_1 = require("../errors/errors.control-service");
+const fam_error_data_model_1 = require("../../../_models/data-models/fam-error.data-model");
 const embedding_1 = require("../../../_modules/embedding");
 const ingest_1 = require("../../../_modules/ingest");
 const mcp_1 = require("../../../_modules/mcp");
+const fam_doctor_control_service_1 = require("./fam-doctor.control-service");
+const retrieval_1 = require("../../../_modules/retrieval");
+const fam_request_origin_util_1 = require("../../../_collections/fam-request-origin.util");
 /** A UI/CLI lapozás CCAP-örökség konstansai (dsgn-010/dsgn-011 §4.1). */
 const DEFAULT_PAGE_SIZE = 50;
 const MAX_PAGE_SIZE = 500;
@@ -53,6 +61,9 @@ class Api_Controller extends nts_dynamo_1.DyNTS_Controller {
             this.writeEndpoint(),
             this.capabilitiesEndpoint(),
             this.healthEndpoint(),
+            this.doctorEndpoint(),
+            this.rulesInjectEndpoint(),
+            this.rulesPropagateEndpoint(),
             this.itemsEndpoint(),
             this.statsEndpoint(),
             this.statsTableEndpoint(),
@@ -60,6 +71,12 @@ class Api_Controller extends nts_dynamo_1.DyNTS_Controller {
             this.duplicatesEndpoint(),
             this.configGetEndpoint(),
             this.configSetEndpoint(),
+            this.scanStartEndpoint(),
+            this.scanStatusEndpoint(),
+            this.scanJobsEndpoint(),
+            this.scanCancelEndpoint(),
+            this.errorsSummaryEndpoint(),
+            this.errorsEndpoint(),
         ];
     }
     // =========================================================================
@@ -110,6 +127,14 @@ class Api_Controller extends nts_dynamo_1.DyNTS_Controller {
                         // Heap-load-shed (OOM-hibakezelés): a NEHÉZ write-eket (scan/import/re-embed) critical
                         // memória-nyomásnál elutasítjuk (503), MIELŐTT egy nagy allokáció átlökné a plafont.
                         this.assertHeapCapacity(String(input.operation));
+                        // FEAT-008 (user-FR 2026-06-22): a NEHÉZ write-ek SZERVER-OLDALI QUEUE-n mennek át → a szerver
+                        // szerializálja őket (egyszerre egy), így több agent egyidejű write-jai sorba rakódnak, és nincs
+                        // párhuzamos scan-feldolgozás (a war-factory/warbots átfedés gyökér-megoldása). A könnyű ops
+                        // (create/update/delete) bypass-olják a queue-t. Lásd `FAM_OperationQueue_Service`.
+                        if (Api_Controller.HEAVY_WRITE_OPERATIONS.includes(String(input.operation))) {
+                            return fam_operation_queue_service_1.FAM_OperationQueue_Service.getInstance()
+                                .enqueue(() => mcp_1.FAM_WriteTool_Service.getInstance().handle(input));
+                        }
                         return mcp_1.FAM_WriteTool_Service.getInstance().handle(input);
                     });
                 },
@@ -132,9 +157,235 @@ class Api_Controller extends nts_dynamo_1.DyNTS_Controller {
             ],
         });
     }
+    /**
+     * `POST /scan/start` (FEAT-008) — szerver-oldali multi-projekt scan-job INDÍTÁSA. Body: explicit `projects` VAGY
+     * `root` (felderítés a SZERVEREN) + opcionális cooldown-override. AZONNAL visszaad `{ jobId, total }` (a hosszú
+     * feldolgozás háttérben fut → nincs Node-requestTimeout). A progress a `GET /scan/status/:jobId`-on.
+     */
+    scanStartEndpoint() {
+        return new nts_dynamo_1.DyNTS_Endpoint_Params({
+            name: 'scanStart',
+            type: fsm_dynamo_1.DyFM_HttpCallType.post,
+            endpoint: '/scan/start',
+            tasks: [
+                async (req, res) => {
+                    await this.run(res, async () => {
+                        const input = (req.body ?? {});
+                        // Aláírás-feloldás (user-FR 2026-06-25): a `X-FAM-*` header VAGY a body `origin` → KI indította
+                        // a scant (több egyidejű workspace-session beazonosítható). A job-on + a lista-nézetben látszik.
+                        input.origin = fam_request_origin_util_1.FAM_RequestOrigin_Util.fromRequest(req, input.origin);
+                        return fam_scan_job_control_service_1.FAM_ScanJob_ControlService.getInstance().start(input);
+                    });
+                },
+            ],
+        });
+    }
+    /** `GET /scan/status/:jobId` (FEAT-008) — egy scan-job állapota (progress + per-projekt eredmények). 404, ha ismeretlen. */
+    scanStatusEndpoint() {
+        return new nts_dynamo_1.DyNTS_Endpoint_Params({
+            name: 'scanStatus',
+            type: fsm_dynamo_1.DyFM_HttpCallType.get,
+            endpoint: '/scan/status/:jobId',
+            tasks: [
+                async (req, res) => {
+                    await this.run(res, async () => {
+                        const job = fam_scan_job_control_service_1.FAM_ScanJob_ControlService.getInstance().getStatus(String(req.params.jobId));
+                        if (!job) {
+                            throw new fsm_dynamo_1.DyFM_Error({
+                                errorCode: 'FAM-SCAN-JOB-404',
+                                message: `Ismeretlen scan-job: '${String(req.params.jobId)}' (lehet, hogy a szerver `
+                                    + 'újraindult — a job-ok in-memory tárolódnak).',
+                                issuer: this.issuer,
+                            });
+                        }
+                        return job;
+                    });
+                },
+            ],
+        });
+    }
+    /**
+     * `GET /scan/jobs` (FEAT-008 Phase 5 — „jobb job kezelés") — AZ ÖSSZES (futó + befejezett) scan-job KOMPAKT listája,
+     * legfrissebb elöl. Egy elárvult/futó job a `jobId` ISMERETE NÉLKÜL is felfedezhető (+ a stall-jelzés is látszik).
+     */
+    scanJobsEndpoint() {
+        return new nts_dynamo_1.DyNTS_Endpoint_Params({
+            name: 'scanJobs',
+            type: fsm_dynamo_1.DyFM_HttpCallType.get,
+            endpoint: '/scan/jobs',
+            tasks: [
+                async (req, res) => {
+                    await this.run(res, async () => ({ jobs: fam_scan_job_control_service_1.FAM_ScanJob_ControlService.getInstance().listJobs() }));
+                },
+            ],
+        });
+    }
+    /**
+     * `POST /scan/cancel/:jobId` (FEAT-008 Phase 5) — egy FUTÓ scan-job megszakítás-kérése (a processor a következő projekt
+     * ELŐTT ellenőrzi). `{ cancelled: true }`, ha a job létezett + futott; `false`, ha ismeretlen/már terminál.
+     */
+    scanCancelEndpoint() {
+        return new nts_dynamo_1.DyNTS_Endpoint_Params({
+            name: 'scanCancel',
+            type: fsm_dynamo_1.DyFM_HttpCallType.post,
+            endpoint: '/scan/cancel/:jobId',
+            tasks: [
+                async (req, res) => {
+                    await this.run(res, async () => ({
+                        cancelled: fam_scan_job_control_service_1.FAM_ScanJob_ControlService.getInstance().cancel(String(req.params.jobId)),
+                    }));
+                },
+            ],
+        });
+    }
+    /**
+     * `GET /errors` (→ `/api/errors`, user-FR 2026-06-24: „kéne legyenek végpontok, amivel le tudjuk érni az errorokat")
+     * — a `fam_errors` rekordok KOMPAKT, FAM-natív nézete a `/api` felületen (a built-in `/api/server/errors` nyers/bő
+     * Dynamo-objektumai helyett). Query: `code` (errorCode-részlet, case-insensitive), `unhandledOnly` (`true` → csak nem
+     * kezeltek), `limit` (default 50, max 500). Sorrend: occurrence DESC, majd recency. A `contextSnapshot` (benne a
+     * `failedSample` + provider/table/operation) is kijön — így az LM-Studio-omlasztó tartalom-séma diagnosztizálható.
+     */
+    errorsEndpoint() {
+        return new nts_dynamo_1.DyNTS_Endpoint_Params({
+            name: 'errorsList',
+            type: fsm_dynamo_1.DyFM_HttpCallType.get,
+            endpoint: '/errors',
+            tasks: [
+                async (req, res) => {
+                    await this.run(res, async () => {
+                        const unhandledOnly = req.query.unhandledOnly === 'true';
+                        const codeFilter = req.query.code ? String(req.query.code).toLowerCase() : '';
+                        const limit = Math.min(500, Math.max(1, Number(req.query.limit) || 50));
+                        const all = await errors_control_service_1.FAM_Error_ControlService.getInstance()
+                            .listErrors(unhandledOnly ? { handled: false } : undefined);
+                        const filtered = all
+                            .filter((r) => !codeFilter || (r.errorCode ?? '').toLowerCase().includes(codeFilter))
+                            .sort((a, b) => fam_error_data_model_1.FAM_Error_DataModel.occurrenceCount(b) - fam_error_data_model_1.FAM_Error_DataModel.occurrenceCount(a)
+                            || String(b._id ?? '').localeCompare(String(a._id ?? '')));
+                        return {
+                            total: filtered.length,
+                            returned: Math.min(limit, filtered.length),
+                            errors: filtered.slice(0, limit).map((r) => this.mapErrorCompact(r)),
+                        };
+                    });
+                },
+            ],
+        });
+    }
+    /**
+     * `GET /errors/summary` (→ `/api/errors/summary`) — errorCode szerint CSOPORTOSÍTOTT triage-nézet: kódonként az
+     * occurrence-összeg + distinct rekordszám + utolsó üzenet + egy reprezentatív `failedSample`. Gyors „mi omlik a
+     * legtöbbet" áttekintés (pl. melyik `FAM-EMB-PROVIDER-002` séma viszi el az LM Studio-t).
+     */
+    errorsSummaryEndpoint() {
+        return new nts_dynamo_1.DyNTS_Endpoint_Params({
+            name: 'errorsSummary',
+            type: fsm_dynamo_1.DyFM_HttpCallType.get,
+            endpoint: '/errors/summary',
+            tasks: [
+                async (req, res) => {
+                    await this.run(res, async () => {
+                        const all = await errors_control_service_1.FAM_Error_ControlService.getInstance().listErrors();
+                        const groups = {};
+                        for (const r of all) {
+                            const code = r.errorCode ?? '(no-code)';
+                            const group = groups[code] ?? { errorCode: code, occurrences: 0, records: 0 };
+                            group.occurrences += fam_error_data_model_1.FAM_Error_DataModel.occurrenceCount(r);
+                            group.records += 1;
+                            group.lastMessage = r.message ?? group.lastMessage;
+                            const sample = r.contextSnapshot?.failedSample;
+                            if (sample && !group.sampleFailedSample) {
+                                group.sampleFailedSample = String(sample).slice(0, 400);
+                            }
+                            groups[code] = group;
+                        }
+                        return {
+                            groups: Object.values(groups).sort((a, b) => b.occurrences - a.occurrences),
+                        };
+                    });
+                },
+            ],
+        });
+    }
+    /** Egy `fam_errors` rekord → KOMPAKT, FAM-natív hiba-nézet (a nyers Dynamo-mezők/óriás-stack helyett a diagnózishoz kell). */
+    mapErrorCompact(record) {
+        return {
+            id: String(record._id ?? ''),
+            errorCode: record.errorCode,
+            level: typeof Reflect.get(record, 'level') === 'string' ? String(Reflect.get(record, 'level')) : undefined,
+            message: record.message,
+            occurrenceCount: fam_error_data_model_1.FAM_Error_DataModel.occurrenceCount(record),
+            handled: record.handled ?? false,
+            issuer: record.issuer,
+            context: record.contextSnapshot,
+        };
+    }
     // =========================================================================
     // /health — CLI remote reachability-check (dsgn-010 §9)
     // =========================================================================
+    /**
+     * `GET /doctor` (#2 diagnosztikai végpont, user-FR 2026-06-24) — SZERVER-OLDALI aggregált health-report
+     * (env/mongodb/config/embedding/vector/collections + scope-integritás), a `fam doctor` REST-tükre (ADR-015
+     * server-centric: a CLI/kliens/UI/külső eszköz EZT hívja, nem 6 külön capability-t). Opcionális `?skip=embedding,vector`.
+     */
+    doctorEndpoint() {
+        return new nts_dynamo_1.DyNTS_Endpoint_Params({
+            name: 'doctor',
+            type: fsm_dynamo_1.DyFM_HttpCallType.get,
+            endpoint: '/doctor',
+            tasks: [
+                async (req, res) => {
+                    await this.run(res, async () => {
+                        const skipRaw = typeof req.query.skip === 'string' ? req.query.skip : '';
+                        const skip = skipRaw.split(',').map((entry) => entry.trim()).filter((entry) => entry.length > 0);
+                        return fam_doctor_control_service_1.FAM_Doctor_ControlService.getInstance().runDoctor({ skip: skip });
+                    });
+                },
+            ],
+        });
+    }
+    /**
+     * `POST /rules/inject` (Rules-Management MP-2) — a SessionStart-hook (+ a `read`-reflex) szerver-oldali rule-assembly-je:
+     * a `cwd`-ből (vagy explicit felülírásból) detektált tier-kontextusra `importance`-rangsorolt, char-budgetbe illesztett
+     * always-apply rule-blokk a „(…and N more)" záró sorral. A hook DUMB marad (csak `additionalContext`-be teszi a `block`-ot).
+     * Body: `{ cwd?, isFdp?, inProject?, projectType?, topics?, budgetChars? }`.
+     */
+    rulesInjectEndpoint() {
+        return new nts_dynamo_1.DyNTS_Endpoint_Params({
+            name: 'rulesInject',
+            type: fsm_dynamo_1.DyFM_HttpCallType.post,
+            endpoint: '/rules/inject',
+            tasks: [
+                async (req, res) => {
+                    await this.run(res, async () => {
+                        const input = (req.body ?? {});
+                        return retrieval_1.FAM_RuleInjection_ControlService.getInstance().assembleInjection(input);
+                    });
+                },
+            ],
+        });
+    }
+    /**
+     * `POST /rules/propagate` (Rules-Management MP-5) — a kontextusra érvényes szabályok GENERÁLT, marker-keretezett
+     * `CLAUDE.md`-blokkja (propagáció a FAM-NÉLKÜLI projekt-agenteknek). Budget nélkül (minden alkalmazható szabály),
+     * dedup `ruleId`/`derivedFrom` szerint. A hívó (sync-tool/CLI) a `block`-ot a projekt-`CLAUDE.md` markerei közé illeszti.
+     * Body: `{ cwd?, isFdp?, inProject?, projectType?, topics? }`.
+     */
+    rulesPropagateEndpoint() {
+        return new nts_dynamo_1.DyNTS_Endpoint_Params({
+            name: 'rulesPropagate',
+            type: fsm_dynamo_1.DyFM_HttpCallType.post,
+            endpoint: '/rules/propagate',
+            tasks: [
+                async (req, res) => {
+                    await this.run(res, async () => {
+                        const input = (req.body ?? {});
+                        return retrieval_1.FAM_RuleInjection_ControlService.getInstance().assemblePropagation(input);
+                    });
+                },
+            ],
+        });
+    }
     /** `GET /health` — a CLI `--server-url` elérhetőség-próbája (dsgn-010 §9). */
     healthEndpoint() {
         return new nts_dynamo_1.DyNTS_Endpoint_Params({
@@ -145,10 +396,17 @@ class Api_Controller extends nts_dynamo_1.DyNTS_Controller {
                 async (req, res) => {
                     // A heap-nyomás IS kimegy a health-en (observability) — a BEDROCK DyNTS_MemoryGuard pressure-éből.
                     const memory = nts_dynamo_2.DyNTS_MemoryGuard.getInstance().pressure();
+                    // Hidratálás-állapot (user-FR 2026-06-22): a boot-hidratálás időbe telik → a hívó lássa, kész-e.
+                    const hydration = fam_vector_search_control_service_1.FAM_VectorSearch_ControlService.getInstance().hydrationSummary();
+                    // Readiness-coordinator per-tár állapot (pending/hydrating/ready/failed) — a read-queue diagnosztikája.
+                    const readiness = embedding_1.FAM_HydrationCoordinator_ControlService.getInstance().snapshot();
                     res.send({
                         ok: true, service: 'fdp-agent-memory', version: fam_version_const_1.FAM_VERSION, uptime: process.uptime(),
+                        ready: hydration.complete,
                         memory: { level: memory.level, heapUsedMb: memory.heapUsedMb, heapLimitMb: memory.heapLimitMb,
                             heapPct: memory.heapPct, rssMb: memory.rssMb, gcFraction: memory.gcFraction },
+                        hydration: hydration,
+                        readiness: readiness,
                     });
                 },
             ],
@@ -344,12 +602,24 @@ class Api_Controller extends nts_dynamo_1.DyNTS_Controller {
                 async (req, res) => {
                     await this.run(res, async () => {
                         const table = this.parseTable(req.params.table);
+                        // A vessző-szeparált lista-paraméterek (projects/excludeProjects) tömbbé bontása.
+                        const parseList = (value) => (typeof value === 'string' && value.length
+                            ? value.split(',').map((item) => item.trim()).filter((item) => item.length > 0)
+                            : undefined);
                         return embedding_1.FAM_DuplicateScan_ControlService.getInstance().scan({
                             table: table,
                             threshold: req.query.threshold !== undefined ? Number(req.query.threshold) : undefined,
                             neighbors: req.query.neighbors !== undefined ? this.parseNumber(req.query.neighbors, 10) : undefined,
                             maxEntries: req.query.maxEntries !== undefined ? this.parseNumber(req.query.maxEntries, 3000) : undefined,
                             maxClusters: req.query.maxClusters !== undefined ? this.parseNumber(req.query.maxClusters, 100) : undefined,
+                            pathRegex: typeof req.query.pathRegex === 'string' && req.query.pathRegex.length ? req.query.pathRegex : undefined,
+                            excludePathRegex: typeof req.query.excludePathRegex === 'string' && req.query.excludePathRegex.length
+                                ? req.query.excludePathRegex : undefined,
+                            excludeRootRegex: typeof req.query.excludeRootRegex === 'string' && req.query.excludeRootRegex.length
+                                ? req.query.excludeRootRegex : undefined,
+                            projects: parseList(req.query.projects),
+                            excludeProjects: parseList(req.query.excludeProjects),
+                            minProjects: req.query.minProjects !== undefined ? this.parseNumber(req.query.minProjects, 0) : undefined,
                         });
                     });
                 },