@futdevpro/fdp-agent-memory 1.1.122 → 1.1.133

package/build/src/_modules/mcp/_collections/fam-read-response-shape.util.js

@@ -0,0 +1,167 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FAM_ReadResponseShape_Util = void 0;
+/**
+ * `FAM_ReadResponseShape_Util` — a `read` VÁLASZ-FORMÁZÁSA az agent-fogyasztóknak (user-FR 2026-07-29, agent-panaszok:
+ * „a FAM túl nagy csomag válaszokat ad" / „formázatlan, tördeletlen egy soros válaszokat kapnak" / „az eredményekből
+ * kiolvasható fájl elérési útvonalak nem állnak össze").
+ *
+ * **Alapelv: NULLA információ-veszteség.** Nem dobunk el tudást — csak (a) a DUPLIKÁCIÓT szüntetjük meg (ugyanaz az
+ * útvonal 3 mezőben, ugyanaz az abszolút út a `source`-ban is), (b) az agent számára HASZNÁLHATATLAN belső kulcsokat
+ * hagyjuk el (`contentHash` dedup-kulcs, opak `scopeId`-k), (c) a 17-jegyű float-okat értelmes pontosságra kerekítjük.
+ * Minden megmaradó tény továbbra is elérhető, csak EGY, egyértelmű helyen.
+ *
+ * A transzformáció a read-tool KIMENETÉN fut, így az MCP és a REST `/api/read` is ezt kapja; a belső retrieval-DTO
+ * (és a kliens/CLI fogyasztói) érintetlenek.
+ */
+class FAM_ReadResponseShape_Util {
+    /** A score-ok megjelenítési pontossága (0.5530494673617745 → 0.5530) — a rangsorhoz bőven elég. */
+    static SCORE_DECIMALS = 4;
+    /**
+     * Egy hit KOMPAKT, agent-barát alakja. **Útvonal-SSOT (a #3 panasz gyökere):** eddig HÁROM különböző útvonal-mező
+     * volt HÁROM különböző bázissal (`sourceFilePath` a scan-root-hoz relatív → az agent nem tudta feloldani;
+     * `absolutePath`; `source.repoRelativePath`), ezért „nem álltak össze". Mostantól:
+     * - **`path`** — a MEGNYITHATÓ útvonal: abszolút, VAGY a `basePath`-hoz relatív, ha a hívó adott ilyet. EZ a SSOT.
+     * - **`repoPath`** — repo-relatív út + repo-név (git-hivatkozáshoz), CSAK ha ismert.
+     * A régi mezők (`sourceFilePath`/`absolutePath`) MEGMARADNAK a visszafelé-kompatibilitásért, de a `path` az elsődleges.
+     */
+    static compactHit(hit) {
+        const source = hit.source;
+        const round = (value) => typeof value === 'number' ? Number(value.toFixed(FAM_ReadResponseShape_Util.SCORE_DECIMALS)) : undefined;
+        const compact = {
+            id: hit.id,
+            table: hit.table,
+            // ÚTVONAL-SSOT: a `sourceFilePath` már a hívó `basePath`-jához igazított (rebaseToBasePath), különben az
+            // abszolút út — így MINDIG feloldható. A régi mezőket lentebb megtartjuk (kompatibilitás).
+            path: hit.sourceFilePath ?? hit.absolutePath ?? null,
+            score: round(hit.score),
+            finalScore: round(hit.finalScore),
+        };
+        if (hit.lexicalScore !== undefined) {
+            compact.lexicalScore = round(hit.lexicalScore);
+        }
+        if (hit.weight !== undefined && hit.weight !== 1) {
+            compact.weight = hit.weight;
+        }
+        // Lokáció a fájlon BELÜL (melyik szekció / hányadik sor) — a „hol nézzem meg" kérdésre.
+        if (hit.headingPath?.length) {
+            compact.heading = hit.headingPath.join(' › ');
+        }
+        const position = hit.position;
+        if (position?.lineStart) {
+            compact.lines = position.lineEnd && position.lineEnd !== position.lineStart
+                ? `${position.lineStart}-${position.lineEnd}`
+                : String(position.lineStart);
+        }
+        if (hit.chunkType) {
+            compact.chunkType = hit.chunkType;
+        }
+        if (hit.kind) {
+            compact.kind = hit.kind;
+        }
+        if (hit.tags?.length) {
+            compact.tags = hit.tags;
+        }
+        // Scope: az opak `scopeId`-k helyett ember/agent-olvasható `layer=név` lánc (a szűkítéshez ezt kell megadni).
+        const scopePath = (hit.scopePath ?? []);
+        if (scopePath.length) {
+            compact.scope = scopePath.map((ref) => `${ref.layer}=${ref.canonicalName}`).join('/');
+        }
+        // Repo-hivatkozás (git-link) — csak ha van; a `source` többi mezője (root/path/absolutePath) DUPLIKÁCIÓ volt.
+        if (source?.repoName && source?.repoRelativePath) {
+            compact.repoPath = `${source.repoName}:${source.repoRelativePath}`;
+        }
+        if (source?.type) {
+            compact.sourceType = source.type;
+        }
+        // Rules-specifikus kurátor-mezők (ha vannak) — ezek döntik el, MENNYIRE kötelező a szabály.
+        for (const key of ['ruleId', 'ruleScope', 'importance', 'userApproved', 'category']) {
+            const value = hit[key];
+            if (value !== undefined && value !== null) {
+                compact[key] = value;
+            }
+        }
+        if (hit.lastModifiedMs) {
+            compact.lastModified = new Date(hit.lastModifiedMs).toISOString().slice(0, 10);
+        }
+        // A TARTALOM a végére — így a metaadat-fej egyben olvasható a hosszú szöveg előtt.
+        if (hit.content !== undefined) {
+            compact.content = hit.content;
+        }
+        // Visszafelé-kompatibilitás: a `sourceFilePath` MEGMARAD (a kliens `ma-search` erre a mezőnévre épül) — értéke
+        // AZONOS a `path`-szal, tehát alias, nem harmadik igazság. Az `absolutePath` viszont CSAK akkor kerül bele, ha
+        // ténylegesen ELTÉR (azaz `basePath`-rebase történt, és így külön információt hordoz) — különben szó szerinti
+        // duplikáció lenne, ami épp a panaszolt „nagy csomag" + „az útvonalak nem állnak össze" problémát okozta.
+        compact.sourceFilePath = hit.sourceFilePath ?? null;
+        if (hit.absolutePath && hit.absolutePath !== compact.path) {
+            compact.absolutePath = hit.absolutePath;
+        }
+        return compact;
+    }
+    /**
+     * OPERATÍV VISSZAJELZÉS (user-FR 2026-07-29 — általános MCP-követelmény): „a tool-ok adjanak visszajelzést a
+     * működésről: összesen N elem között kerestünk, M tűnik relevánsnak, K megjelenítve + mit tegyél, hogy mindet
+     * lásd / fájlba írd / célzottabban keress". PURE — a számokból épít egy mondatot + konkrét, MÁSOLHATÓ tippeket.
+     */
+    static buildSummary(set) {
+        const scope = set.tables.length ? set.tables.join('+') : 'minden tár';
+        const searched = set.searchedCount > 0
+            ? `${FAM_ReadResponseShape_Util.humanCount(set.searchedCount)} elem között kerestünk`
+            : 'a keresés lefutott';
+        const relevant = `${set.totalRelevant} tűnik magabiztosan relevánsnak`;
+        const shown = set.truncated
+            ? `${set.shown} megjelenítve (topK=${set.topK} vágta)`
+            : `mind a ${set.shown} megjelenítve`;
+        return `[${scope}] ${searched} · ${relevant} · ${shown}.`;
+    }
+    /** A summary melletti, KONKRÉT következő lépések (csak a releváns tippek — nincs zaj). PURE. */
+    static buildHints(set) {
+        const hints = [];
+        if (set.truncated) {
+            const all = Math.max(set.totalRelevant, set.shown);
+            hints.push(`MIND: futtasd újra \`topK: ${all}\`-val (vagy \`depth: "deep"\`-pel a mélyebb feltárásért).`);
+            hints.push('FÁJLBA: a CLI-vel `fam read --query "…" --json > talalatok.json` (nagy találat-halmaznál ez '
+                + 'a javasolt út — a chat-választ nem terheli).');
+        }
+        if (set.totalRelevant > set.shown * 3 && !set.hasScopeFilter) {
+            hints.push('CÉLZOTTABBAN: szűkíts `scope`-pal (pl. `{"layer":"project","name":"<projekt>"}`), `tags`-szel '
+                + 'vagy `kind`-dal — a sok találat általában túl tág kérdést jelez.');
+        }
+        if (!set.totalRelevant) {
+            hints.push('NINCS magabiztos találat: próbálj más megfogalmazást/kulcsszavakat, vagy emeld a `topK`-t; '
+                + 'a `minScore: 0` a leggyengébb tippeket is visszaadja.');
+        }
+        return hints;
+    }
+    /** Rövid, ember-olvasható darabszám (12 400 → „12.4k"). PURE. */
+    static humanCount(count) {
+        if (count < 1000) {
+            return String(count);
+        }
+        if (count < 1000000) {
+            const thousands = count / 1000;
+            return `${thousands >= 100 ? Math.round(thousands) : Number(thousands.toFixed(1))}k`;
+        }
+        return `${Number((count / 1000000).toFixed(1))}M`;
+    }
+    /** Egy teljes result-blokk formázása: kompakt hit-ek + summary + hints (a result többi mezője érintetlen). */
+    static shapeResult(set) {
+        const hits = set.result.hits ?? [];
+        const shaped = { ...set.result };
+        shaped.summary = FAM_ReadResponseShape_Util.buildSummary({
+            tables: set.tables, searchedCount: set.searchedCount, totalRelevant: set.result.totalRelevant ?? 0,
+            shown: hits.length, truncated: Boolean(set.result.truncated), topK: set.topK,
+        });
+        const hints = FAM_ReadResponseShape_Util.buildHints({
+            totalRelevant: set.result.totalRelevant ?? 0, shown: hits.length,
+            truncated: Boolean(set.result.truncated), hasScopeFilter: Boolean(set.hasScopeFilter),
+        });
+        if (hints.length) {
+            shaped.hints = hints;
+        }
+        shaped.searchedCount = set.searchedCount;
+        shaped.hits = hits.map((hit) => FAM_ReadResponseShape_Util.compactHit(hit));
+        return shaped;
+    }
+}
+exports.FAM_ReadResponseShape_Util = FAM_ReadResponseShape_Util;

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

@@ -337,6 +337,9 @@ class FAM_CapabilityRegistry_Service {
                 projects: { type: 'array', items: { type: 'string' }, description: 'Csak ezek a projektek (scopePath project-layer canonicalName).' },
                 excludeProjects: { type: 'array', items: { type: 'string' }, description: 'Kizárt projektek (fork-zaj — pl. ccap — elnyomása).' },
                 minProjects: { type: 'number', description: 'Csak a legalább ennyi KÜLÖNBÖZŐ projektet átfedő clusterek (default 2).' },
+                minContentLength: { type: 'number', description: 'Minimális content-hossz (karakter) — a rövid boilerplate-zaj kizárása a prefilterben (dup-v2).' },
+                suppressForkPairs: { type: 'boolean', description: 'A fork-gyanús projekt-párokra eső clusterek elnyomása a kimenetben (default false; dup-v2).' },
+                includeCoverage: { type: 'boolean', description: 'A lefedettség-preflight beágyazása az eredménybe (default true; dup-v2).' },
             }),
             handler: async (args) => {
                 const input = this.asObject(args);
@@ -352,9 +355,73 @@ class FAM_CapabilityRegistry_Service {
                     projects: this.asStringArray(input.projects),
                     excludeProjects: this.asStringArray(input.excludeProjects),
                     minProjects: this.asNumber(input.minProjects) ?? 2,
+                    minContentLength: this.asNumber(input.minContentLength),
+                    suppressForkPairs: input.suppressForkPairs === true,
+                    includeCoverage: input.includeCoverage !== false,
                 }));
             },
         });
+        // detect_exact_duplication (dup-v2, task #20): EXACT (contentHash-azonos) duplikáció-mérés egyetlen
+        // Mongo-aggregációval — a TELJES szűrt halmazon fut (nincs maxEntries-cap, nincs vektor-számítás), így a
+        // flotta-szintű „mennyi az exact duplikáció?" kérdés kanonikus mérője. A near-dup scan (fent) a drift-elt
+        // másolatokra való; ez a bitre-azonos sokszorozódásra.
+        this.register({
+            name: 'detect_exact_duplication', category: category,
+            description: 'EXACT (contentHash-azonos) duplikáció-mérés (read-only; dup-v2 task #20): egyetlen Mongo-'
+                + 'aggregáció a TELJES szűrt halmazon (a 300k-s codebase táron is cap nélkül fut). Kimenet: totals '
+                + '(totalGroups/redundantCopies/wastedChars) + top-N csoport (wasted DESC, projekt-/repo-lefedettséggel '
+                + '+ fájl-listával) + fork-pár statisztika (`forkPairs`) + a ≥4-projektes csoport-hash-ek + '
+                + 'lefedettség-preflight (`coverage`, default be). A `suppressForkPairs` a fork-gyanús párokra eső '
+                + 'csoportokat elnyomja a listából (a totals a mért valóság marad). A `minContentLength` a rövid '
+                + 'boilerplate-zajt szűri (ajánlott: 200).',
+            inputSchema: this.objectSchema({
+                table: this.tableSchema(false),
+                pathRegex: { type: 'string', description: 'A sourceFilePath include-regexe (case-insensitive).' },
+                excludePathRegex: { type: 'string', description: 'A sourceFilePath exclude-regexe.' },
+                excludeRootRegex: { type: 'string', description: 'A source.root exclude-regexe (pl. "STALE-projects").' },
+                projects: { type: 'array', items: { type: 'string' }, description: 'Csak ezek a projektek (scopePath project-layer canonicalName).' },
+                excludeProjects: { type: 'array', items: { type: 'string' }, description: 'Kizárt projektek.' },
+                minProjects: { type: 'number', description: 'Csak a legalább ennyi KÜLÖNBÖZŐ projektet átfedő csoportok (default 1).' },
+                minContentLength: { type: 'number', description: 'Minimális content-hossz karakterben (default 0; ajánlott 200 a boilerplate-zaj ellen).' },
+                maxGroups: { type: 'number', description: 'A visszaadott top-csoportok száma (default 100, hard cap 500; a totals a teljes halmazon számolt).' },
+                maxFilesPerGroup: { type: 'number', description: 'Per-csoport fájl-lista cap (default 20; a filesTruncated jelzi a csonkolást).' },
+                suppressForkPairs: { type: 'boolean', description: 'A fork-gyanús projekt-párokra eső csoportok elnyomása a listából (default false).' },
+                includeCoverage: { type: 'boolean', description: 'A lefedettség-preflight beágyazása (default true).' },
+            }),
+            handler: async (args) => {
+                const input = this.asObject(args);
+                return this.ok(await embedding_1.FAM_ExactDuplication_ControlService.getInstance().run({
+                    table: this.optionalTable(input.table),
+                    pathRegex: this.asString(input.pathRegex),
+                    excludePathRegex: this.asString(input.excludePathRegex),
+                    excludeRootRegex: this.asString(input.excludeRootRegex),
+                    projects: this.asStringArray(input.projects),
+                    excludeProjects: this.asStringArray(input.excludeProjects),
+                    minProjects: this.asNumber(input.minProjects),
+                    minContentLength: this.asNumber(input.minContentLength),
+                    maxGroups: this.asNumber(input.maxGroups),
+                    maxFilesPerGroup: this.asNumber(input.maxFilesPerGroup),
+                    suppressForkPairs: input.suppressForkPairs === true,
+                    includeCoverage: input.includeCoverage !== false,
+                }));
+            },
+        });
+        // duplication_coverage_report (dup-v2, task #20): a dup-mérés lefedettség-preflight-je ÖNÁLLÓ eszközként —
+        // mely projektek hiányoznak (0 entry) vagy elavultak a korpuszból (a „nincs duplikáció X-szel" hamis-negatív
+        // gyanújának ellenőrzése a mérés ELŐTT/UTÁN).
+        this.register({
+            name: 'duplication_coverage_report', category: category,
+            description: 'A dup-mérés LEFEDETTSÉG-preflight riportja (read-only; dup-v2): a scope-fa project-layer '
+                + 'listája × a tár per-projekt entry-száma + a legfrissebb entry kora. Kimenet: zeroEntryProjects '
+                + '(a mérésből NÉMÁN kimaradók), staleProjects (> 8 nap), per-projekt sorok (entryCount DESC) + '
+                + 'warnings. A dup-eredmény flotta-szintű értelmezésének előfeltétele.',
+            inputSchema: this.objectSchema({ table: this.tableSchema(false) }),
+            handler: async (args) => {
+                const input = this.asObject(args);
+                return this.ok(await embedding_1.FAM_DupCoverage_ControlService.getInstance()
+                    .report(this.optionalTable(input.table) ?? fam_table_type_enum_1.FAM_Table.codebase));
+            },
+        });
     }
     /** maintenance → MP-2 (re-embed) + MP-3 (rebuild reference index). */
     registerMaintenance() {

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

@@ -110,13 +110,18 @@ class FAM_Mcp_Adapter_Service {
         }
         return 'Ismeretlen hiba a tool-végrehajtás során.';
     }
-    /** JSON-stringify (a transport text-content payload-ja). */
+    /**
+     * JSON-stringify (a transport text-content payload-ja) — **TÖRDELVE** (user-FR 2026-07-29, agent-panasz:
+     * „formázatlan, tördeletlen egy soros válaszokat kapnak"). A 2-szóközös indentálás soronként EGY mezőt ad, így a
+     * válasz olvasható/diffelhető; a token-költség elhanyagolható a beágyazott `content`-ek mellett, cserébe az agent
+     * (és a `truncate`-elő host) sokkal jobban tudja kezelni.
+     */
     stringify(data) {
         try {
-            return JSON.stringify(data);
+            return JSON.stringify(data, null, 2);
         }
         catch {
-            return JSON.stringify({ ok: false, error: { message: 'A válasz nem szerializálható JSON-ra.' } });
+            return JSON.stringify({ ok: false, error: { message: 'A válasz nem szerializálható JSON-ra.' } }, null, 2);
         }
     }
 }

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

@@ -9,6 +9,8 @@ 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 retrieval_1 = require("../../retrieval");
+const embedding_1 = require("../../embedding");
+const fam_read_response_shape_util_1 = require("../_collections/fam-read-response-shape.util");
 /**
  * `FAM_ReadTool_Service` (SP-6.2, dsgn-003 §2) — a `read` core-tool **transport-agnosztikus**
  * handler-je. Singleton. EGY belépési pont (`handle`), amit MIND az MCP-tool (stdio), MIND a REST
@@ -47,7 +49,33 @@ class FAM_ReadTool_Service {
         // levágódik + a túlcsorduló hit-ek elhagyva, `truncated:true`-val. A FAM mindig DIREKT adja vissza a találatokat.
         FAM_ReadTool_Service.applyTokenBudget(response, await FAM_ReadTool_Service.resolveMaxTokens(input));
         this.logReadActivity(input, response);
-        return response;
+        // AGENT-BARÁT VÁLASZ-FORMA (user-FR 2026-07-29): kompakt hit-ek (duplikált útvonal-mezők + opak belső kulcsok
+        // nélkül, kerekített score-okkal) + OPERATÍV VISSZAJELZÉS (mennyi közt kerestünk / mennyi releváns / mennyi
+        // látszik + konkrét következő lépések). Információ NEM vész el — csak a duplikáció és a zaj.
+        return FAM_ReadTool_Service.shapeResponse(response, input);
+    }
+    /**
+     * A válasz agent-barát formázása (user-FR 2026-07-29). Per-query blokkonként hozzáadja a `summary`/`hints`/
+     * `searchedCount` mezőket és kompaktálja a hit-eket. A `searchedCount` a ténylegesen átkutatott vektor-pool
+     * mérete (a query tárainak összege) — ez adja a „N elem között kerestünk" visszajelzést.
+     */
+    static shapeResponse(response, input) {
+        const vectorSearch = embedding_1.FAM_VectorSearch_ControlService.getInstance();
+        const shaped = (response.results ?? []).map((result, index) => {
+            const query = input.queries?.[index];
+            const tables = (query?.tables ?? []);
+            const pool = tables.length ? tables : embedding_1.FAM_STORE_REGISTRY.map((entry) => entry.table);
+            const searchedCount = pool.reduce((sum, table) => sum + vectorSearch.getPoolSize(table), 0);
+            return fam_read_response_shape_util_1.FAM_ReadResponseShape_Util.shapeResult({
+                result: result,
+                tables: tables.map((table) => String(table)),
+                searchedCount: searchedCount,
+                topK: query?.topK ?? result.hits?.length ?? 0,
+                // Ha a hívó MÁR szűkített (scope/tag/kind), a „szűkíts jobban" tipp fölösleges zaj lenne.
+                hasScopeFilter: Boolean(query?.scopeFilter?.length || query?.tagFilter?.length || query?.kindFilter),
+            });
+        });
+        return { ...response, results: shaped };
     }
     /**
      * A `read.maxTokens` config feloldása (default/fallback 4000, min 256) — a QUERY-K TÁRAIRA feloldva (user-FR
@@ -89,7 +117,20 @@ class FAM_ReadTool_Service {
      */
     static applyTokenBudget(response, maxTokens) {
         const charBudget = Math.max(256, maxTokens) * 4;
-        const metaPerHit = 220; // a per-hit metaadat (score/path/heading/…) durva char-költsége
+        // A per-hit metaadat TÉNYLEGES char-költsége (2026-07-29 lelet): eddig egy fix `220`-as becslés volt, miközben a
+        // valódi metaadat ~790-1400 char — vagyis a budget 3-6×-osan ALULBECSÜLT, és a válasz rendszeresen túllépte a
+        // `read.maxTokens`-ben ígért méretet (ez volt a „túl nagy csomag" panasz egyik oka). Most a KIMENŐ (kompaktált)
+        // alakot mérjük, mert az agent azt kapja meg — így a budget végre igazat mond.
+        const metaCost = (hit) => {
+            try {
+                const shaped = fam_read_response_shape_util_1.FAM_ReadResponseShape_Util.compactHit(hit);
+                delete shaped.content;
+                return JSON.stringify(shaped).length;
+            }
+            catch {
+                return 220;
+            }
+        };
         const results = response.results ?? [];
         if (!results.length) {
             return;
@@ -104,11 +145,12 @@ class FAM_ReadTool_Service {
                 if (!hit) {
                     continue;
                 }
-                if (used + metaPerHit >= charBudget) {
+                const hitMeta = metaCost(hit);
+                if (used + hitMeta >= charBudget) {
                     budgetExhausted = true;
                     break;
                 }
-                used += metaPerHit;
+                used += hitMeta;
                 if (typeof hit.content === 'string' && hit.content.length > 0) {
                     const remaining = charBudget - used;
                     if (hit.content.length > remaining) {
@@ -137,14 +179,18 @@ class FAM_ReadTool_Service {
      * hit (nem-scan, pl. agent-write) érintetlen. basePath nélkül no-op (a `sourceFilePath` a scan-gyökérhez relatív marad).
      */
     rebaseToBasePath(response, basePath) {
-        if (!basePath) {
-            return;
-        }
         for (const block of response.results ?? []) {
             for (const hit of block.hits ?? []) {
-                if (hit.absolutePath) {
-                    hit.sourceFilePath = path.relative(basePath, hit.absolutePath).replace(/\\/g, '/');
+                if (!hit.absolutePath) {
+                    continue;
                 }
+                // ÚTVONAL-SSOT (user-FR 2026-07-29 — „az eredményekből kiolvasható fájl elérési útvonalak nem állnak
+                // össze"): a `sourceFilePath` eddig a SCAN-ROOT-hoz volt relatív (pl. `global/core-x.md`), amit a hívó
+                // NEM tudott feloldani (a scan-root nem szerepelt a válaszban). Mostantól: `basePath` esetén ahhoz
+                // relatív, KÜLÖNBEN az ABSZOLÚT út — vagyis a mező MINDIG megnyitható útvonalat ad.
+                hit.sourceFilePath = basePath
+                    ? path.relative(basePath, hit.absolutePath).replace(/\\/g, '/')
+                    : hit.absolutePath;
             }
         }
     }

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

@@ -46,8 +46,43 @@ class FAM_WriteTool_Service {
         this.validate(input);
         const output = await this.dispatch(input);
         this.logWriteActivity(input, output);
+        // OPERATÍV VISSZAJELZÉS (user-FR 2026-07-29): egy mondat arról, MI TÖRTÉNT — az agentnek ne a nyers ID-tömbökből
+        // kelljen visszafejtenie az eredményt (ugyanaz az elv, mint a `read` summary-jénél).
+        output.summary = FAM_WriteTool_Service.buildSummary(output);
         return output;
     }
+    /**
+     * A write-eredmény egy mondatban (PURE, tesztelhető). Csak a TÉNYLEGESEN történt dolgokat sorolja (üres részeket
+     * nem említ), scan-nél a fájl/chunk-számot + a delta-verdikteket, és a figyelmeztetések számát.
+     */
+    static buildSummary(output) {
+        const parts = [];
+        if (output.created.length) {
+            parts.push(`${output.created.length} létrehozva`);
+        }
+        if (output.updated.length) {
+            parts.push(`${output.updated.length} frissítve`);
+        }
+        if (output.deleted.length) {
+            parts.push(`${output.deleted.length} törölve`);
+        }
+        if (output.scan) {
+            const verdicts = output.scan.verdicts;
+            parts.push(`${output.scan.filesProcessed} fájl → ${output.scan.chunks} chunk `
+                + `(${verdicts.new} új / ${verdicts.modified} módosult / ${verdicts.equal} változatlan`
+                + `${verdicts.deleted ? ` / ${verdicts.deleted} törölt` : ''})`);
+        }
+        if (output.reEmbed) {
+            parts.push(`re-embed: ${output.reEmbed.reembedded}/${output.reEmbed.total} `
+                + `(${output.reEmbed.skipped} kihagyva, ${output.reEmbed.failed} hibás)`);
+        }
+        if (!parts.length) {
+            parts.push('nem változott semmi');
+        }
+        const status = output.ok ? 'OK' : 'HIBA';
+        const warnings = output.warnings.length ? ` · ${output.warnings.length} figyelmeztetés` : '';
+        return `[${output.operation} → ${output.table}] ${status}: ${parts.join(' · ')}${warnings}`;
+    }
     /** Az operation-router (a `handle` validáció + activity-log közé ékelve, dsgn-003 §3). */
     async dispatch(input) {
         switch (input.operation) {

package/build/src/_modules/retrieval/_collections/fam-rule-propagation.util.js

@@ -47,7 +47,7 @@ class FAM_RulePropagation_Util {
         const lines = [];
         lines.push(opts?.heading ?? '## FDP Agent Hard-Rules (synced from FAM)');
         lines.push('');
-        lines.push('> Generated from the canonical rule set. Edit the rules in `documentations/rules/`, not here.');
+        lines.push('> Generated from the canonical rule set. Edit the rules in `fdp-documentations/rules/`, not here.');
         for (const group of FAM_RulePropagation_Util.SCOPE_ORDER) {
             const inScope = deduped
                 .filter((rule) => rule.ruleScope === group.scope)