@futdevpro/fdp-agent-memory 0.1.0 → 1.1.14

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

@@ -1,6 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FAM_ReadTool_Service = void 0;
+const tslib_1 = require("tslib");
+const path = tslib_1.__importStar(require("path"));
+const fsm_dynamo_1 = require("@futdevpro/fsm-dynamo");
 const fam_table_type_enum_1 = require("../../../_enums/fam-table.type-enum");
 const error_codes_const_1 = require("../../../_collections/error-codes.const");
 const fam_error_factory_util_1 = require("../../../_collections/fam-error-factory.util");
@@ -36,7 +39,54 @@ class FAM_ReadTool_Service {
     async handle(input) {
         this.validate(input);
         const request = this.toRetrievalRequest(input);
-        return retrieval_1.FAM_Retrieval_ControlService.getInstance().read(request);
+        const response = await retrieval_1.FAM_Retrieval_ControlService.getInstance().read(request);
+        this.rebaseToBasePath(response, input.basePath);
+        this.logReadActivity(input, response);
+        return response;
+    }
+    /**
+     * Ha a kérés `basePath`-et ad, a hit-ek `sourceFilePath`-ját a KANONIKUS `absolutePath`-ból a `basePath`-hez
+     * RELATÍVAN írjuk át (a hívó saját workspace-kontextusa — FAM-REV-050), `/`-normalizálva. `absolutePath` nélküli
+     * 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, '/');
+                }
+            }
+        }
+    }
+    /**
+     * Egy-soros activity-log a read-műveletről (FEAT-001 console). A `[famRead]` prefix konzisztens a
+     * `[famIngest]`/`[famImport]` MON-eseményekkel. Diagnosztika — NEM befolyásolja a választ.
+     */
+    logReadActivity(input, response) {
+        let totalHits = 0;
+        let topScore = 0;
+        for (const block of response.results ?? []) {
+            for (const hit of block.hits ?? []) {
+                totalHits++;
+                const score = hit.finalScore ?? hit.score ?? 0;
+                if (score > topScore) {
+                    topScore = score;
+                }
+            }
+        }
+        const tables = Array.from(new Set(input.queries.flatMap((query) => query.tables ?? []))).join(',');
+        const firstQuery = FAM_ReadTool_Service.truncate(input.queries[0]?.query ?? '');
+        const more = input.queries.length > 1 ? ` (+${input.queries.length - 1} query)` : '';
+        const top = totalHits ? `, top ${topScore.toFixed(3)}` : '';
+        fsm_dynamo_1.DyFM_Log.info(`[famRead] "${firstQuery}"${more} [${tables}] → ${totalHits} találat${top}`);
+    }
+    /** Egy keresési phrase rövidítése a log-sorhoz (whitespace-collapse + max 60 karakter). */
+    static truncate(text) {
+        const clean = text.replace(/\s+/g, ' ').trim();
+        return clean.length > 60 ? `${clean.slice(0, 57)}…` : clean;
     }
     /**
      * A `read` input validációja (dsgn-003 §2.1). Üres `queries` / üres `tables` / `reference` a
@@ -93,6 +143,8 @@ class FAM_ReadTool_Service {
             scopeFilter: query.scopeFilter,
             tagFilter: query.tagFilter,
             kindFilter: query.kindFilter,
+            excludeIds: query.excludeIds,
+            depth: query.depth,
         };
     }
 }

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

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FAM_WriteTool_Service = 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_entry_data_model_1 = require("../../../_models/data-models/fam-entry.data-model");
@@ -42,6 +43,12 @@ class FAM_WriteTool_Service {
      */
     async handle(input) {
         this.validate(input);
+        const output = await this.dispatch(input);
+        this.logWriteActivity(input, output);
+        return output;
+    }
+    /** Az operation-router (a `handle` validáció + activity-log közé ékelve, dsgn-003 §3). */
+    async dispatch(input) {
         switch (input.operation) {
             case fam_mcp_interface_1.FAM_WriteOperation.create:
                 return this.handleCreate(input);
@@ -67,6 +74,34 @@ class FAM_WriteTool_Service {
                 });
         }
     }
+    /**
+     * Egy-soros activity-log egy write-műveletről (FEAT-001 console). A `scan-*` a `[famIngest]`, az
+     * `import` a `[famImport]` strukturált MON-eseményén logol — itt a create/update/delete/re-embed humán
+     * egy-sorosa (`[famWrite]`, konzisztens a többi MON-prefixszel). Diagnosztika — NEM befolyásolja a választ.
+     */
+    logWriteActivity(input, output) {
+        if (input.operation === fam_mcp_interface_1.FAM_WriteOperation.import || output.scan) {
+            return;
+        }
+        let summary;
+        if (output.reEmbed) {
+            summary = `${output.reEmbed.reembedded}/${output.reEmbed.total} re-embed`;
+        }
+        else {
+            const parts = [];
+            if (output.created.length) {
+                parts.push(`+${output.created.length}`);
+            }
+            if (output.updated.length) {
+                parts.push(`~${output.updated.length}`);
+            }
+            if (output.deleted.length) {
+                parts.push(`-${output.deleted.length}`);
+            }
+            summary = parts.length ? parts.join(' ') : '∅';
+        }
+        fsm_dynamo_1.DyFM_Log.info(`[famWrite] ${input.operation} ${input.table} → ${summary}`);
+    }
     // =========================================================================
     // Validáció (dsgn-003 §3.1 / §6.3)
     // =========================================================================
@@ -203,16 +238,26 @@ class FAM_WriteTool_Service {
     async handleDelete(input) {
         const registryEntry = this.requireRegistryEntry(input.table, 'write-delete');
         const dataService = new embedding_1.FAM_Entry_DataService({ dataParams: registryEntry.dataParams, issuer: this.issuer });
-        const targetEntry = await this.resolveTarget(input, dataService, 'write-delete');
-        const deletedId = targetEntry._id ?? '';
-        if (deletedId) {
-            // absolute=false → soft-delete (a Dynamo-konvenció: a _deleted marker, archív collection).
-            await dataService.deleteData(deletedId, false);
+        // FAM-REV-051 bulk: `sourceFilePath`/`absolutePath` → egy fájl ÖSSZES chunkja; `id`/`query` → egyetlen.
+        const targets = await this.resolveDeleteTargets(input, dataService, 'write-delete');
+        const deletedIds = [];
+        for (const entry of targets) {
+            if (!entry._id) {
+                continue;
+            }
+            // absolute=false → soft-delete (Dynamo-konvenció: `_deleted` marker, archív collection).
+            await dataService.deleteData(entry._id, false);
+            // Pool-coherence (FAM-REV-046): a törölt vektort a hívó-process in-memory LVS-pool-jából is kivesszük.
+            embedding_1.FAM_VectorSearch_ControlService.getInstance().removeVector(input.table, entry._id);
+            deletedIds.push(entry._id);
         }
+        const warnings = deletedIds.length > 1
+            ? [`Bulk file-delete: ${deletedIds.length} chunk soft-delete-elve (cél: ${input.target?.by}='${input.target?.value}').`]
+            : [];
         return this.baseOutput({
             operation: input.operation, table: input.table,
-            scopePath: (targetEntry.scopePath ?? []),
-            uncertaintyNotes: [], deleted: deletedId ? [deletedId] : [], warnings: [],
+            scopePath: (targets[0]?.scopePath ?? []),
+            uncertaintyNotes: [], deleted: deletedIds, warnings: warnings,
         });
     }
     // =========================================================================
@@ -232,6 +277,7 @@ class FAM_WriteTool_Service {
             include: scan.include,
             exclude: scan.exclude,
             dryRun: scan.dryRun,
+            weights: scan.weights,
             issuer: this.issuer,
         };
         let summary;
@@ -254,7 +300,7 @@ class FAM_WriteTool_Service {
             created: [], updated: [], deleted: [], scopePath: summary.scopePath,
             scan: {
                 filesProcessed: summary.filesProcessed, chunks: summary.chunkCount,
-                verdicts: summary.verdicts, status: summary.status,
+                verdicts: summary.verdicts, status: summary.status, estimate: summary.estimate,
             },
             ingestRunId: summary.ingestRunId, uncertaintyNotes: [], warnings: warnings,
         };
@@ -420,6 +466,56 @@ class FAM_WriteTool_Service {
         }
         return matches[0];
     }
+    /**
+     * A DELETE cél-entry-k feloldása — BULK (FAM-REV-051). `by:id` → 1 entry; `by:sourceFilePath` /
+     * `by:absolutePath` → a fájl ÖSSZES chunkja (egy szkennelt fájl mindig több chunk → így törölhető egy
+     * lépésben); `by:query` → a `content`-substring match, de a véletlen tömeges törlés ellen TÖBB-matchnél
+     * megtagad (egyértelmű cél kell). Nincs match → `FAM-VAL-WRITE-003`. Az `absolutePath` a kanonikus,
+     * scan-root-független azonosító (FAM-REV-050) — ajánlott egész-fájl törléshez.
+     */
+    async resolveDeleteTargets(input, dataService, operation) {
+        const target = input.target;
+        if (!target || !target.by || !target.value) {
+            throw fam_error_factory_util_1.FAM_Error_Util.create({
+                errorCode: error_codes_const_1.FAM_ERROR_CODES.valWriteTargetAmbiguous,
+                message: 'A `delete` művelethez `target` kötelező ({ by: id|sourceFilePath|absolutePath|query, value }).',
+                issuer: this.issuer,
+                context: { operation: operation, table: input.table },
+            });
+        }
+        if (target.by === 'id') {
+            const byId = await dataService.findData({ _id: target.value }, true);
+            if (!byId || !byId._id) {
+                throw this.targetNotFound(input, target, operation);
+            }
+            return [byId];
+        }
+        const filter = {};
+        if (target.by === 'sourceFilePath') {
+            filter.sourceFilePath = target.value;
+        }
+        else if (target.by === 'absolutePath') {
+            filter['source.absolutePath'] = target.value;
+        }
+        else {
+            filter.content = target.value; // query
+        }
+        const matches = await dataService.findDataList(filter);
+        if (!matches.length) {
+            throw this.targetNotFound(input, target, operation);
+        }
+        // `query`-mód: a véletlen tömeges törlés ellen egyértelműséget követelünk (a fájl-módok BULK-ok).
+        if (target.by === 'query' && matches.length > 1) {
+            throw fam_error_factory_util_1.FAM_Error_Util.create({
+                errorCode: error_codes_const_1.FAM_ERROR_CODES.valWriteTargetAmbiguous,
+                message: `A 'query'='${target.value}' cél több (${matches.length}) entry-re illeszkedik — `
+                    + 'pontosíts (`by:id`), vagy egész fájlhoz használj `by:sourceFilePath`/`by:absolutePath`-t (BULK).',
+                issuer: this.issuer,
+                context: { operation: operation, table: input.table },
+            });
+        }
+        return matches;
+    }
     /** A cél nem található → `FAM-VAL-WRITE-003` (deskriptív). */
     targetNotFound(input, target, operation) {
         return fam_error_factory_util_1.FAM_Error_Util.create({

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

@@ -5,15 +5,15 @@
  * a REST-réteg (`_routes/server/api`, SP-6.5: a transport-agnosztikus core `FAM_*Tool_Service`-ek a
  * REST-mirrorhoz), és a contract-tesztek (advertised-tool + diszjunkció).
  *
- * Boundary (dsgn-003 §5, BFR-AM-003): a `FAM_Mcp_Adapter` az EGYETLEN choke-pont a hivatalos
+ * Boundary (dsgn-003 §5, BFR-AM-003): a `FAM_Mcp_Adapter_Service` az EGYETLEN choke-pont a hivatalos
  * `@modelcontextprotocol/sdk` köré — a bedrock `DyNTS_Mcp_*` (MP-15) csere itt non-breaking. A 3
  * core-tool + a capability-registry transport-agnosztikus (MCP stdio + REST UGYANEZT hívja).
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.FAM_WriteOperation = exports.FAM_CapabilityCategory = exports.FAM_CapabilityRegistry = exports.FAM_CapabilitiesTool_Service = exports.FAM_WriteTool_Service = exports.FAM_ReadTool_Service = exports.FAM_CORE_TOOLS = exports.FAM_McpServer_Service = exports.FAM_Mcp_Adapter = void 0;
+exports.FAM_WriteOperation = exports.FAM_CapabilityCategory = exports.FAM_CapabilityRegistry_Service = exports.FAM_CapabilitiesTool_Service = exports.FAM_WriteTool_Service = exports.FAM_ReadTool_Service = exports.FAM_CORE_TOOLS = exports.FAM_McpServer_Service = exports.FAM_Mcp_Adapter_Service = void 0;
 // SP-6.1 — MCP infra (adaptor + szerver-orchestrátor)
 var fam_mcp_adapter_service_1 = require("./_services/fam-mcp-adapter.service");
-Object.defineProperty(exports, "FAM_Mcp_Adapter", { enumerable: true, get: function () { return fam_mcp_adapter_service_1.FAM_Mcp_Adapter; } });
+Object.defineProperty(exports, "FAM_Mcp_Adapter_Service", { enumerable: true, get: function () { return fam_mcp_adapter_service_1.FAM_Mcp_Adapter_Service; } });
 var fam_mcp_server_service_1 = require("./_services/fam-mcp-server.service");
 Object.defineProperty(exports, "FAM_McpServer_Service", { enumerable: true, get: function () { return fam_mcp_server_service_1.FAM_McpServer_Service; } });
 var fam_core_tools_const_1 = require("./_collections/fam-core-tools.const");
@@ -28,7 +28,7 @@ Object.defineProperty(exports, "FAM_WriteTool_Service", { enumerable: true, get:
 var fam_capabilities_tool_service_1 = require("./_services/fam-capabilities-tool.service");
 Object.defineProperty(exports, "FAM_CapabilitiesTool_Service", { enumerable: true, get: function () { return fam_capabilities_tool_service_1.FAM_CapabilitiesTool_Service; } });
 var fam_capability_registry_service_1 = require("./_services/fam-capability-registry.service");
-Object.defineProperty(exports, "FAM_CapabilityRegistry", { enumerable: true, get: function () { return fam_capability_registry_service_1.FAM_CapabilityRegistry; } });
+Object.defineProperty(exports, "FAM_CapabilityRegistry_Service", { enumerable: true, get: function () { return fam_capability_registry_service_1.FAM_CapabilityRegistry_Service; } });
 // shared vokabulár (a REST-réteg + a contract-tesztek fogyasztják)
 var fam_mcp_interface_1 = require("./_models/interfaces/fam-mcp.interface");
 Object.defineProperty(exports, "FAM_CapabilityCategory", { enumerable: true, get: function () { return fam_mcp_interface_1.FAM_CapabilityCategory; } });

package/build/src/_modules/migration/_collections/fam-claude-mem-normalize.util.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FAM_ClaudeMemNormalize_Util = void 0;
 const fam_claude_mem_interface_1 = require("../_models/interfaces/fam-claude-mem.interface");
+const fam_prompt_aggregate_util_1 = require("./fam-prompt-aggregate.util");
 /**
  * `FAM_ClaudeMemNormalize_Util` (SP-11.1) — a nyers forrás-rekordokat (observations / summaries /
  * prompts / sessions) a KÖZÖS `FAM_ClaudeMemRecord` köztes shape-re normalizálja. MINDEN reader
@@ -33,10 +34,13 @@ class FAM_ClaudeMemNormalize_Util {
                 records.push(record);
             }
         }
-        // user_prompts CSAK includePrompts:true esetén (default OFF — dsgn-009 §2 / §9.7).
+        // user_prompts CSAK includePrompts:true esetén (default OFF — dsgn-009 §2 / §9.7). L3 §3: a promptokat
+        // ELŐBB AGGREGÁLJUK (signature-dedup) — az ismétlődő sablonok (pl. automata-trigger üzenetek) EGY
+        // kanonikus bejegyzésbe vonva (+ repeatCount/projects/dateRange metaadat), az egyediek megmaradnak.
         if (set.includePrompts) {
-            for (const prompt of set.prompts) {
-                const record = FAM_ClaudeMemNormalize_Util.normalizePrompt(prompt, warnings);
+            const aggregated = fam_prompt_aggregate_util_1.FAM_PromptAggregate_Util.aggregate(set.prompts, set.sessions);
+            for (const item of aggregated) {
+                const record = FAM_ClaudeMemNormalize_Util.normalizeAggregatedPrompt(item, warnings);
                 if (record) {
                     records.push(record);
                 }
@@ -143,6 +147,65 @@ class FAM_ClaudeMemNormalize_Util {
             createdAtEpoch: typeof raw.created_at_epoch === 'number' ? raw.created_at_epoch : undefined,
         };
     }
+    /**
+     * Egy AGGREGÁLT prompt-csoport → record (L3 §3). Egyedi prompt (`repeatCount:1`) → normál prompt-record; az
+     * ismétlődő sablon (`repeatCount>1`) → EGY kanonikus record + aggregátum-metaadat: a stats a `title`-ben (a
+     * `composeContent` bekomponálja → kereshető), az `aggregated-prompt`/`automation-trigger` a `concepts`-ben
+     * (→ tag). A content-hash dedup így a kanonikuson dolgozik (nulla duplikáció). A VALÓS sqlite-oszlopokat is
+     * olvassa (`prompt_text`/`content_session_id` — a `normalizePrompt` látens drift-fixe is).
+     */
+    static normalizeAggregatedPrompt(item, warnings) {
+        const raw = item.representative;
+        const sessionId = FAM_ClaudeMemNormalize_Util.cleanString(raw.claude_session_id ?? raw.content_session_id);
+        const promptNumber = typeof raw.prompt_number === 'number' ? raw.prompt_number : undefined;
+        const sourceRowId = sessionId !== undefined && promptNumber !== undefined
+            ? `${sessionId}:${promptNumber}`
+            : FAM_ClaudeMemNormalize_Util.toStringId(raw.id);
+        if (!sourceRowId) {
+            warnings.push('Egy aggregált user_prompt azonosító nélkül érkezett — kihagyva.');
+            return null;
+        }
+        if (!item.text) {
+            warnings.push('Egy aggregált user_prompt szöveg nélkül érkezett — kihagyva.');
+            return null;
+        }
+        const concepts = [];
+        let title = undefined;
+        if (item.repeatCount > 1) {
+            concepts.push('aggregated-prompt');
+            if (item.isAutomationTrigger) {
+                concepts.push('automation-trigger');
+            }
+            title = FAM_ClaudeMemNormalize_Util.aggregateTitle(item);
+        }
+        return {
+            entity: fam_claude_mem_interface_1.FAM_ClaudeMemEntity_Type.userPrompt,
+            sourceRowId: sourceRowId,
+            sdkSessionId: FAM_ClaudeMemNormalize_Util.cleanString(raw.sdk_session_id),
+            claudeSessionId: sessionId,
+            project: item.projects.length ? item.projects[0] : FAM_ClaudeMemNormalize_Util.cleanString(raw.project),
+            promptNumber: promptNumber,
+            title: title,
+            text: item.text,
+            concepts: concepts,
+            filesRead: [],
+            filesModified: [],
+            createdAtEpoch: item.dateRange ? item.dateRange.fromEpoch
+                : (typeof raw.created_at_epoch === 'number' ? raw.created_at_epoch : undefined),
+        };
+    }
+    /** Az ismétlődő prompt-sablon ember-olvasható aggregátum-címe (a `composeContent` ezt is bekomponálja). */
+    static aggregateTitle(item) {
+        const projectPart = item.projects.length
+            ? ` · ${item.projects.length} projekt (${item.projects.join(', ')})`
+            : '';
+        const dayPart = item.dateRange
+            ? ` · ${item.distinctDays} nap (${new Date(item.dateRange.fromEpoch).toISOString().slice(0, 10)}…`
+                + `${new Date(item.dateRange.toEpoch).toISOString().slice(0, 10)})`
+            : '';
+        const autoPart = item.isAutomationTrigger ? ' [automata-trigger]' : '';
+        return `Ismétlődő prompt-sablon — ${item.repeatCount}×${projectPart}${dayPart}${autoPart}`;
+    }
     /** Egy id (string vagy number) string-re — üres/undefined → ''. */
     static toStringId(id) {
         if (id === undefined || id === null) {

package/build/src/_modules/migration/_collections/fam-prompt-aggregate.util.js

@@ -0,0 +1,143 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FAM_PromptAggregate_Util = void 0;
+/**
+ * `FAM_PromptAggregate_Util` (L3 §3) — a 11 975 claude-mem `user_prompt` **okos dedup-ja** import előtt. A
+ * promptokat **normalizált signature** szerint csoportosítja (számok → `#`, lowercase, whitespace-collapse), és:
+ *  - **n=1** (egyedi, valódi info) → marad;
+ *  - **ismétlődő sablon (n>1)** → EGY kanonikus bejegyzés + aggregátum-metaadat (`repeatCount`/`projects`/
+ *    `distinctDays`/`dateRange` + `automation-trigger` jelölés) → **nulla duplikáció, de a minta megőrizve**.
+ *
+ * A `projects[]` az `sdk_sessions.project`-ből a `content_session_id`-join-on (a `user_prompts`-ban nincs
+ * közvetlen project). Determinista (azonos input → azonos output): a csoport-reprezentáns az ELSŐ (read-order)
+ * prompt, a projektek/napok rendezettek. Tisztán statikus (nincs DB/async).
+ */
+class FAM_PromptAggregate_Util {
+    /** E küszöb FELETT egy sablon `automation-trigger` jelölést kap (a genuinely automatizált üzenetek). */
+    static AUTOMATION_THRESHOLD = 5;
+    /**
+     * **Triviális (noise) flow-control promptok** — önmagukban NULLA információ (user-direktíva: „`continue`/
+     * `Continue`/`Continue.` stb. kiszűrése"). Ezeket NEM importáljuk (még aggregálva sem): tiszta vezérlő-zaj.
+     * A bázis-formák (írásjel/whitespace nélkül, lowercase); az `isTrivialPrompt` strip-eli a körülvevő írásjelet,
+     * így a `Continue.` / `go!` / ` ok ` variánsok mind ide esnek.
+     */
+    static TRIVIAL_PROMPTS = new Set([
+        'continue', 'continue working', 'continue please', 'please continue', 'pls continue',
+        'go', 'go on', 'go ahead', 'keep going', 'carry on', 'proceed', 'proceed please',
+        'next', 'more', 'resume', 'do it', 'do it.', 'continue from where you left off',
+        'yes', 'yep', 'yeah', 'yup', 'ok', 'okay', 'k', 'kk', 'sure', 'y', 'fine',
+        'continue towards the hyper plan', 'continue the hyper plan', 'continue hyperplan',
+    ]);
+    /**
+     * Triviális (noise) flow-control prompt-e (`continue`/`go`/`yes`/`ok`/… írásjel-/whitespace-variánsokkal)?
+     * A körülvevő írásjelet (`. ! , ; : -`) + whitespace-et strip-eljük, lowercase + collapse, majd a
+     * `TRIVIAL_PROMPTS` bázis-halmaz ellen vetjük. Az ilyen prompt önmagában értéktelen → kihagyjuk az importból.
+     */
+    static isTrivialPrompt(text) {
+        const normalized = text
+            .toLowerCase()
+            .replace(/[\s.!,;:\-–—]+$/u, '')
+            .replace(/^[\s.!,;:\-–—]+/u, '')
+            .replace(/\s+/g, ' ')
+            .trim();
+        return normalized.length > 0 && FAM_PromptAggregate_Util.TRIVIAL_PROMPTS.has(normalized);
+    }
+    /** A nyers promptok aggregálása signature szerint (a `sessions` a project-join forrása). */
+    static aggregate(prompts, sessions) {
+        const projectBySession = FAM_PromptAggregate_Util.buildProjectIndex(sessions);
+        // Signature → a csoport promptjai (read-order megőrizve a determinisztikus reprezentánshoz).
+        const groups = new Map();
+        for (const prompt of prompts) {
+            const text = FAM_PromptAggregate_Util.promptText(prompt);
+            if (!text || FAM_PromptAggregate_Util.isTrivialPrompt(text)) {
+                // Üres VAGY triviális (noise) flow-control prompt → kihagyjuk (nem aggregáljuk, nem importáljuk).
+                continue;
+            }
+            const signature = FAM_PromptAggregate_Util.signature(text);
+            const bucket = groups.get(signature);
+            if (bucket) {
+                bucket.push(prompt);
+            }
+            else {
+                groups.set(signature, [prompt]);
+            }
+        }
+        const items = [];
+        for (const group of groups.values()) {
+            items.push(FAM_PromptAggregate_Util.toAggregated(group, projectBySession));
+        }
+        return items;
+    }
+    /**
+     * Egy prompt-szöveg normalizált **signature**-je a sablon-egyezéshez: a számok `#`-re (a sorszámozott
+     * variánsok — `(1/5)` / `step 3` — egy sablonba essenek), lowercase, és a whitespace egyetlen szóközre.
+     */
+    static signature(text) {
+        return text.toLowerCase().replace(/\d+/g, '#').replace(/\s+/g, ' ').trim();
+    }
+    /** Egy prompt szövege (`prompt_text` — tényleges sqlite-oszlop — VAGY `text` — export-json). */
+    static promptText(prompt) {
+        const text = prompt.prompt_text ?? prompt.text;
+        return typeof text === 'string' ? text.trim() : '';
+    }
+    /** A `content_session_id` → `project` index a `sdk_sessions`-ből (a `claude_session_id` fallback). */
+    static buildProjectIndex(sessions) {
+        const index = new Map();
+        for (const session of sessions) {
+            const key = session.content_session_id ?? session.claude_session_id;
+            const project = typeof session.project === 'string' ? session.project.trim() : undefined;
+            if (key && project) {
+                index.set(key, project);
+            }
+        }
+        return index;
+    }
+    /** Egy signature-csoport → aggregált elem (reprezentáns + project/nap/dátum-aggregátum + automata-jelölés). */
+    static toAggregated(group, projectBySession) {
+        const projects = new Set();
+        const days = new Set();
+        let fromEpoch = Number.POSITIVE_INFINITY;
+        let toEpoch = Number.NEGATIVE_INFINITY;
+        for (const prompt of group) {
+            const project = FAM_PromptAggregate_Util.promptProject(prompt, projectBySession);
+            if (project) {
+                projects.add(project);
+            }
+            const epoch = FAM_PromptAggregate_Util.promptEpoch(prompt);
+            if (epoch !== null) {
+                fromEpoch = Math.min(fromEpoch, epoch);
+                toEpoch = Math.max(toEpoch, epoch);
+                days.add(new Date(epoch).toISOString().slice(0, 10));
+            }
+        }
+        return {
+            representative: group[0],
+            text: FAM_PromptAggregate_Util.promptText(group[0]),
+            repeatCount: group.length,
+            projects: [...projects].sort(),
+            distinctDays: days.size,
+            dateRange: toEpoch >= fromEpoch ? { fromEpoch: fromEpoch, toEpoch: toEpoch } : null,
+            isAutomationTrigger: group.length >= FAM_PromptAggregate_Util.AUTOMATION_THRESHOLD,
+        };
+    }
+    /** Egy prompt projektje: közvetlen `project`, VAGY a session-join (`content_session_id`/`claude_session_id`). */
+    static promptProject(prompt, projectBySession) {
+        if (typeof prompt.project === 'string' && prompt.project.trim()) {
+            return prompt.project.trim();
+        }
+        const key = prompt.content_session_id ?? prompt.claude_session_id;
+        return key ? projectBySession.get(key) : undefined;
+    }
+    /** Egy prompt időbélyege epoch-ms-ben (`created_at_epoch`, VAGY `created_at` ISO parse) — vagy `null`. */
+    static promptEpoch(prompt) {
+        if (typeof prompt.created_at_epoch === 'number' && isFinite(prompt.created_at_epoch)) {
+            return prompt.created_at_epoch;
+        }
+        if (typeof prompt.created_at === 'string') {
+            const parsed = Date.parse(prompt.created_at);
+            return isFinite(parsed) ? parsed : null;
+        }
+        return null;
+    }
+}
+exports.FAM_PromptAggregate_Util = FAM_PromptAggregate_Util;

package/build/src/_modules/migration/_collections/fam-target-mapping.util.js

@@ -16,10 +16,22 @@ const OBSERVATION_TYPE_DEFAULTS = {
     discovery: { table: fam_table_type_enum_1.FAM_Table.knowledge, kind: 'knowledge', tags: ['fact', 'discovery'] },
     change: { table: fam_table_type_enum_1.FAM_Table.memory, kind: 'memory_entry', tags: ['development_history', 'change'] },
 };
+/**
+ * Az **agent-memory** (`.claude/.../memory/*.md`) frontmatter-`type` → cél-leképezése: `reference`→knowledge,
+ * `feedback`→**rules** (az agent viselkedési direktívái = aktív szabályok, a read-injekt is innen húz),
+ * `project`→memory, `user`→knowledge. Ismeretlen/hiányzó → az entitás-fallback (memory).
+ */
+const AGENT_MEMORY_TYPE_DEFAULTS = {
+    reference: { table: fam_table_type_enum_1.FAM_Table.knowledge, kind: 'knowledge', tags: ['agent_memory', 'reference'] },
+    feedback: { table: fam_table_type_enum_1.FAM_Table.rules, kind: 'rule', tags: ['agent_memory', 'feedback'] },
+    project: { table: fam_table_type_enum_1.FAM_Table.memory, kind: 'memory_entry', tags: ['agent_memory', 'project'] },
+    user: { table: fam_table_type_enum_1.FAM_Table.knowledge, kind: 'knowledge', tags: ['agent_memory', 'user'] },
+};
 /** A nem-observation entitások default-leképezése (dsgn-009 §4). */
 const ENTITY_DEFAULTS = {
     [fam_claude_mem_interface_1.FAM_ClaudeMemEntity_Type.sessionSummary]: { table: fam_table_type_enum_1.FAM_Table.memory, kind: 'summary', tags: ['session_history'] },
     [fam_claude_mem_interface_1.FAM_ClaudeMemEntity_Type.userPrompt]: { table: fam_table_type_enum_1.FAM_Table.memory, kind: 'user_prompt', tags: ['temporary_context'] },
+    [fam_claude_mem_interface_1.FAM_ClaudeMemEntity_Type.agentMemory]: { table: fam_table_type_enum_1.FAM_Table.memory, kind: 'agent_memory', tags: ['agent_memory'] },
 };
 /**
  * `FAM_TargetMapping_Util` (SP-11.2, dsgn-009 §4) — egy normalizált claude-mem rekord → cél-leképezés
@@ -71,6 +83,13 @@ class FAM_TargetMapping_Util {
             const type = record.type ?? 'change';
             return OBSERVATION_TYPE_DEFAULTS[type] ?? OBSERVATION_TYPE_DEFAULTS.change;
         }
+        if (record.entity === fam_claude_mem_interface_1.FAM_ClaudeMemEntity_Type.agentMemory) {
+            // Az agent-memory a frontmatter-`type`-ról képződik (reference/feedback/project/user); ismeretlen → memory.
+            const type = record.type ?? '';
+            return AGENT_MEMORY_TYPE_DEFAULTS[type]
+                ?? ENTITY_DEFAULTS[fam_claude_mem_interface_1.FAM_ClaudeMemEntity_Type.agentMemory]
+                ?? { table: fam_table_type_enum_1.FAM_Table.memory, kind: 'agent_memory', tags: ['agent_memory'] };
+        }
         return ENTITY_DEFAULTS[record.entity] ?? { table: fam_table_type_enum_1.FAM_Table.memory, kind: 'memory_entry', tags: [] };
     }
     /** A base-tag-ek + a concept-tag-ek egyesítése (rendezett dedup, üres kiszűrve). */

package/build/src/_modules/migration/_enums/fam-claude-mem-source.type-enum.js

@@ -17,4 +17,10 @@ var FAM_ClaudeMemSource_Type;
     FAM_ClaudeMemSource_Type["sqlite"] = "sqlite";
     /** Live worker-api (`http://localhost:<port>`) — opcionális, csak ha a worker fut. */
     FAM_ClaudeMemSource_Type["workerApi"] = "worker-api";
+    /**
+     * **Agent-memory markdown-mappa** (`.claude/.../memory/*.md`) — az agent (Claude) tartós memóriája.
+     * Függőség-mentes (fs + egyszerű frontmatter-parse). UGYANAZ az engine (preview/run/rollback/dedup/embed),
+     * mint a claude-mem-en — csak a reader + a target-mapping (frontmatter-`type`→tár) különbözik.
+     */
+    FAM_ClaudeMemSource_Type["agentMemory"] = "agent-memory";
 })(FAM_ClaudeMemSource_Type || (exports.FAM_ClaudeMemSource_Type = FAM_ClaudeMemSource_Type = {}));

package/build/src/_modules/migration/_models/interfaces/fam-claude-mem.interface.js

@@ -23,4 +23,9 @@ var FAM_ClaudeMemEntity_Type;
     FAM_ClaudeMemEntity_Type["sessionSummary"] = "session_summaries";
     /** user_prompts — opcionális (`memory`, `kind=user_prompt`); default OFF. */
     FAM_ClaudeMemEntity_Type["userPrompt"] = "user_prompts";
+    /**
+     * **agent-memory markdown** (`.claude/.../memory/*.md`) — az agent tartós memória-bejegyzései. A cél-tár a
+     * frontmatter-`type`-tól függ (reference→knowledge, feedback→rules, project→memory, user→knowledge).
+     */
+    FAM_ClaudeMemEntity_Type["agentMemory"] = "agent_memory";
 })(FAM_ClaudeMemEntity_Type || (exports.FAM_ClaudeMemEntity_Type = FAM_ClaudeMemEntity_Type = {}));