@futdevpro/fdp-agent-memory 0.1.0 → 1.1.14

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

@@ -3,9 +3,17 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.FAM_SecretExclude_Util = void 0;
 /**
  * `FAM_SecretExclude_Util` (SP-4.1, dsgn-004 §6.3) — a scan-réteg **fájlnév-/útvonal-alapú**
- * secret-kizárása. A felsorolt minták (`.env*`, `*.key`, `*.pem`, `*.p12`, `id_rsa*`, `*secret*`,
- * `*credential*`, `*.crt`, `secrets/` mappa) **SOHA** nem ingestálódnak; a kizárás a file-típus-
- * routing **ELŐTT** fut, és a kizárt fájlok a `filesSkipped`-be számolódnak (audit, NEM néma).
+ * secret-kizárása. A felsorolt minták (`.env*`, `*.key`, `*.pem`, `*.p12`, `id_rsa*`, `*.crt`,
+ * `secrets/` mappa + a `secret`/`credential` névrész NEM-forrásfájlokon) **SOHA** nem ingestálódnak;
+ * a kizárás a file-típus-routing **ELŐTT** fut, és a kizárt fájlok a `filesSkipped`-be számolódnak
+ * (audit, NEM néma).
+ *
+ * **FALSE-POSITIVE FIX (2026-06-20 audit):** a korábbi `*secret*` / `*credential*` substring-minta
+ * **bármely** forrásfájlt is kizárt, aminek a neve tartalmazta ezeket (pl. maga a
+ * `fam-secret-exclude.util.ts`, vagy egy `secret-manager.service.ts`) → kód-RAG-lefedettség-rés. Ezért
+ * a `secret`/`credential` névrész-minta MOST CSAK **nem-forrás/doc-kiterjesztésekre** alkalmazódik
+ * (egy `.ts`/`.md` fájl, aminek a neve „secret", az KÓD a titokról, NEM titok-fájl). A valódi titok-
+ * fájlok (`.env`/`.key`/`.pem`/…) kiterjesztés-/névalapon továbbra is mindig kizártak.
  *
  * **HATÁR (dsgn-004 §6 megjegyzés + `MP-4-detailed` kockázat) — KIFEJEZETTEN BACKLOG:** ez CSAK
  * fájlnév-/útvonal-alapú kizárás. A **tartalmi** PII/secret-detektálás (a fájlon BELÜLI titkok
@@ -15,12 +23,10 @@ exports.FAM_SecretExclude_Util = void 0;
  */
 class FAM_SecretExclude_Util {
     /**
-     * A beépített secret-fájlnév-minták (dsgn-004 §6.3). Ezek a `scan.ignorePatterns` config
-     * biztonsági default-jával átfedők (dsgn-007 §4.5 `SCAN_IGNORE_PATTERNS_DEFAULT`), de a scan
-     * ettől FÜGGETLENÜL is alkalmazza őket (a config-override NEM kapcsolhatja ki a secret-védelmet).
-     * A vizsgálat a fájlnévre (regex) + az útvonal-szegmensekre (`secrets/`) megy.
+     * HARD secret-fájlnév-minták (dsgn-004 §6.3) — **MINDIG** kizárnak, kiterjesztéstől függetlenül:
+     * ezek a fájlok maguk a titkok (kulcs/cert/env). A config-override NEM kapcsolhatja ki őket.
      */
-    static SECRET_FILENAME_PATTERNS = [
+    static HARD_SECRET_PATTERNS = [
         /^\.env(\..*)?$/i, // .env, .env.local, .env.production, ...
         /\.key$/i, // *.key
         /\.pem$/i, // *.pem
@@ -29,14 +35,24 @@ class FAM_SecretExclude_Util {
         /\.pfx$/i, // *.pfx (cert)
         /^id_rsa.*$/i, // id_rsa, id_rsa.pub, ...
         /^id_ed25519.*$/i, // id_ed25519, id_ed25519.pub
-        /secret/i, // *secret* (bárhol a fájlnévben)
-        /credential/i, // *credential* (bárhol a fájlnévben)
     ];
+    /**
+     * SOFT névrész-minták (`secret`/`credential` bárhol a fájlnévben) — CSAK NEM-forrás/doc-fájlokra
+     * (pl. `secrets.json`, `my-credential.txt`). Egy `.ts`/`.md` fájl, aminek a neve „secret", az KÓD/
+     * DOC a titokról (legit forrás), NEM titok → ingestálódik (false-positive fix, lásd osztály-jsdoc).
+     */
+    static SOFT_SECRET_NAME_PATTERNS = [
+        /secret/i, // *secret* (csak nem-forrás kiterjesztésen)
+        /credential/i, // *credential* (csak nem-forrás kiterjesztésen)
+    ];
+    /** Ismert FORRÁS-/DOC-kiterjesztések — ezeken a SOFT névrész-minta NEM zár ki (legit kód/doc). */
+    static SOURCE_DOC_EXTENSION = /\.(ts|tsx|mts|cts|js|jsx|mjs|cjs|md|markdown)$/i;
     /** A secret-mappák (az útvonal BÁRMELY szegmense — pl. `secrets/`, `.ssh/`). */
     static SECRET_DIR_SEGMENTS = ['secrets', '.ssh', '.gnupg'];
     /**
-     * Secret-e a (projekt-relatív, `/`-normalizált) útvonal — fájlnév-minta VAGY secret-mappa-
-     * szegmens alapján (dsgn-004 §6.3). `true` → SOHA nem ingestálódik (`filesSkipped`, audit).
+     * Secret-e a (projekt-relatív, `/`-normalizált) útvonal — secret-mappa-szegmens VAGY HARD-minta
+     * VAGY (nem-forrásfájlon) SOFT névrész-minta alapján (dsgn-004 §6.3). `true` → SOHA nem ingestálódik
+     * (`filesSkipped`, audit).
      */
     static isSecret(relativePath) {
         const normalized = relativePath.replace(/\\/g, '/');
@@ -47,8 +63,15 @@ class FAM_SecretExclude_Util {
         if (dirSegments.some((segment) => FAM_SecretExclude_Util.SECRET_DIR_SEGMENTS.includes(segment))) {
             return true;
         }
-        // (2) Secret-fájlnév-minta.
-        return FAM_SecretExclude_Util.SECRET_FILENAME_PATTERNS.some((pattern) => pattern.test(fileName));
+        // (2) HARD secret-fájlnév-minta (mindig).
+        if (FAM_SecretExclude_Util.HARD_SECRET_PATTERNS.some((pattern) => pattern.test(fileName))) {
+            return true;
+        }
+        // (3) SOFT névrész-minta — CSAK ha NEM ismert forrás-/doc-kiterjesztés (a "secret"-nevű .ts legit kód).
+        if (FAM_SecretExclude_Util.SOURCE_DOC_EXTENSION.test(fileName)) {
+            return false;
+        }
+        return FAM_SecretExclude_Util.SOFT_SECRET_NAME_PATTERNS.some((pattern) => pattern.test(fileName));
     }
 }
 exports.FAM_SecretExclude_Util = FAM_SecretExclude_Util;

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

@@ -32,6 +32,19 @@ class FAM_SlidingChunker_Util {
             if (paragraphStart >= 0) {
                 charCursor = paragraphStart;
             }
+            // FAM-REV-065: egy paragrafus ÖNMAGÁBAN a maxSize felett (pl. sortörés-nélküli nagy JSON/blob) →
+            // flush + HARD-SPLIT (char-vágás maxSize-onként). KÜLÖNBEN egyetlen óriás-chunk lenne, ami az
+            // embedding-modell token-limitjét túllépi → `error` státusz → a tartalom NEM kereshető (info-veszteség).
+            if (paragraph.length > sizing.maxSize) {
+                if (currentText.trim().length) {
+                    FAM_SlidingChunker_Util.emit(chunks, currentText.trim(), currentCharStart, sizing.minSize);
+                    currentText = '';
+                }
+                FAM_SlidingChunker_Util.hardSplit(chunks, paragraph, charCursor, sizing);
+                charCursor = charCursor + paragraph.length;
+                currentCharStart = charCursor;
+                continue;
+            }
             if (currentText.length && currentText.length + paragraph.length + 2 > sizing.maxSize) {
                 FAM_SlidingChunker_Util.emit(chunks, currentText.trim(), currentCharStart, sizing.minSize);
                 if (currentText.length > sizing.overlap) {
@@ -60,6 +73,27 @@ class FAM_SlidingChunker_Util {
         }
         return chunks;
     }
+    /**
+     * Egy maxSize feletti, természetes törés-pont NÉLKÜLI szöveg HARD-SPLIT-je (FAM-REV-065): char-vágás
+     * `maxSize`-onként, `overlap`-pal lépve. A darabok a `minSize`-szűrés ALÓL MENTESEK (a tail-darab is kell
+     * — semmi ne vesszen el), és a `position` a forrás-offszetre mutat. Így a nagy JSON/blob is embeddelhető
+     * (modell-token-limit alatti darabok), nem ragad `error`-ba.
+     */
+    static hardSplit(chunks, text, charStart, sizing) {
+        const step = Math.max(1, sizing.maxSize - sizing.overlap);
+        for (let i = 0; i < text.length; i += step) {
+            const piece = text.slice(i, i + sizing.maxSize);
+            chunks.push({
+                content: piece,
+                position: { charStart: charStart + i, charEnd: charStart + i + piece.length },
+                chunkType: 'generic',
+                headingPath: [],
+            });
+            if (i + sizing.maxSize >= text.length) {
+                break;
+            }
+        }
+    }
     /** Egy chunk hozzáadása `chunkType='generic'`-kel (zaj-szűrés a `minSize`-ra). */
     static emit(chunks, content, charStart, minSize) {
         if (content.length < minSize) {

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

@@ -5,9 +5,11 @@ exports.FAM_TsChunker_Util = void 0;
  * `FAM_TsChunker_Util` (SP-4.2, dsgn-004 §3.1, **BFR-AM-005 workaround**) — TypeScript-szemantikus
  * chunker `.ts/.tsx/.mts/.js/.jsx`-re. A CCAP `PS_TypeScriptChunker_Util` regex/brace-depth
  * megközelítésének projekt-lokális portja: import-csoport → top-level deklarációk (class/interface/
- * enum/type/function/const-export) → osztály-blokk (a metódus-bontás brace-depth-fel a nagy-blokk
- * ágon történik) → JSDoc + `@Decorator` a következő kód-chunkkal együtt → nagy blokk soronkénti
- * sliding-window-ra bomlik. A méret-konstansok a config-ból (`chunk.ts.*`), default `1500/100/50`.
+ * enum/type/function/const-export) → JSDoc + `@Decorator` a következő kód-chunkkal együtt. A max-size
+ * FELETTI blokk darabolása: **class → metódus-tudatos** (a class-body member-határai mentén; minden adekvát
+ * metódus a saját chunkja `['class:Foo','method:bar']` symbol-lánccal + `chunkType:'method'`, a class-fej +
+ * mezők egy `'class'` chunk), **egyéb nagy blokk** (hosszú függvény/interface/enum) → soronkénti
+ * sliding-window (örökölt chunkType + symbol-lánc). A méret-konstansok a config-ból (`chunk.ts.*`), default `1500/100/50`.
  *
  * **BFR-AM-005 (dsgn-004 §3.1 megjegyzés):** a regex/brace-depth téved string-literálban lévő `{`/`}`
  * vagy template-literál esetén — a `countBraces` konzervatívan kihagyja a string-/line-comment-
@@ -27,6 +29,8 @@ class FAM_TsChunker_Util {
     static TYPE_ALIAS_START = /^(?:export\s+)?type\s+(\w+)\s*=/;
     static STANDALONE_FUNCTION = /^(?:export\s+)?(?:default\s+)?(?:async\s+)?function\s+(\w+)/;
     static CONST_EXPORT = /^(?:export\s+)?const\s+(\w+)/;
+    /** Class-member-signature → metódus-név (modifierek után `név(`); getter/setter/constructor is). */
+    static METHOD_SIG = /^(?:public|private|protected|static|async|readonly|abstract|override|get|set|\s)*\*?\s*([\w$]+)\s*(?:<[^>]*>)?\s*\(/;
     static DECORATOR_LINE = /^\s*@\w+/;
     static JSDOC_OPEN = /^\s*\/\*\*/;
     static JSDOC_CLOSE = /\*\//;
@@ -271,40 +275,222 @@ class FAM_TsChunker_Util {
         }
         return depth;
     }
-    /** Nagy blokk soronkénti sliding-window-ja (örökölt chunkType + symbol-`headingPath`). */
+    /**
+     * Nagy (max-size feletti) blokk darabolása. `class` (entityName-mel) → **metódus-tudatos** member-bontás
+     * (`splitClassByMembers`); egyéb nagy blokk (hosszú függvény/interface/enum) VAGY sikertelen class-parse →
+     * soronkénti sliding-window (`slidingWindowLines`).
+     */
     static splitLargeBlock(block, sizing, headingPath) {
+        if (block.blockType === 'class' && block.entityName) {
+            const classChunks = FAM_TsChunker_Util.splitClassByMembers(block, sizing, headingPath);
+            if (classChunks.length) {
+                return classChunks;
+            }
+        }
+        return FAM_TsChunker_Util.slidingWindowLines({
+            lines: block.lines, charStart: block.charStart, lineStart: block.lineStart,
+            sizing: sizing, headingPath: headingPath, chunkType: block.blockType,
+        });
+    }
+    /**
+     * Soronkénti sliding-window egy sor-tömbre (a nem-class nagy blokkok + a túl nagy egyetlen metódus
+     * fallbackja). Örökli a kapott `chunkType`-ot + `headingPath`-ot; a sub-chunkok a maxSize körül törnek,
+     * `overlap/80` sornyi átfedéssel lépnek.
+     *
+     * **FAM-REV-061:** minden ablak a SAJÁT abszolút `charStart`-ját kapja (a blokk-kezdet + az ablak első
+     * soráig tartó char-offset) — korábban MINDEN ablak `set.charStart`-ot kapott (a blokk kezdete), így a nagy
+     * blokk összes sub-chunkja azonos charStart-ra ütközött (a location-info „hányadik char/sor" félrevezetett).
+     */
+    static slidingWindowLines(set) {
         const chunks = [];
-        const lines = block.lines;
-        const overlapLines = Math.max(1, Math.floor(sizing.overlap / 80));
+        const lines = set.lines;
+        const overlapLines = Math.max(1, Math.floor(set.sizing.overlap / 80));
+        // Sor-kezdő char-offsetek a blokkon belül (a per-ablak abszolút charStart-hoz; +1 a `\n`-ért).
+        const lineCharOffset = [];
+        let acc = 0;
+        for (let i = 0; i < lines.length; i++) {
+            lineCharOffset[i] = acc;
+            acc += lines[i].length + 1;
+        }
         let startIdx = 0;
         while (startIdx < lines.length) {
             let currentText = '';
             let endIdx = startIdx;
             while (endIdx < lines.length) {
                 const candidate = currentText + (currentText ? '\n' : '') + lines[endIdx];
-                if (candidate.length > sizing.maxSize && currentText.length) {
+                if (candidate.length > set.sizing.maxSize && currentText.length) {
                     break;
                 }
                 currentText = candidate;
                 endIdx++;
             }
-            if (currentText.trim().length >= sizing.minSize) {
+            if (currentText.trim().length >= set.sizing.minSize) {
+                const windowCharStart = set.charStart + (lineCharOffset[startIdx] ?? 0);
                 chunks.push({
                     content: currentText,
                     position: {
-                        charStart: block.charStart,
-                        charEnd: block.charStart + currentText.length,
-                        lineStart: block.lineStart + startIdx,
-                        lineEnd: block.lineStart + endIdx - 1,
+                        charStart: windowCharStart,
+                        charEnd: windowCharStart + currentText.length,
+                        lineStart: set.lineStart + startIdx,
+                        lineEnd: set.lineStart + endIdx - 1,
                     },
-                    chunkType: block.blockType,
-                    headingPath: headingPath,
+                    chunkType: set.chunkType,
+                    headingPath: set.headingPath,
                 });
             }
             startIdx = Math.max(startIdx + 1, endIdx - overlapLines);
         }
         return chunks;
     }
+    /**
+     * Metódus-tudatos class-darabolás (FAM-REV-049): a class-body MEMBER-határait (brace-depth) követve a
+     * class-fejet + a metódusokat külön chunkokra bontja — minden adekvát (>= minSize) metódus a saját
+     * chunkja a beágyazott symbol-lánccal (`['class:Foo','method:bar']`, `chunkType:'method'`). A
+     * `parseClassUnits` 1-nél több unitot ad (class-fej + 1+ member) → `packClassUnits`; különben üres
+     * (a hívó soros slidingjára esik).
+     */
+    static splitClassByMembers(block, sizing, classHeadingPath) {
+        const units = FAM_TsChunker_Util.parseClassUnits(block);
+        if (units.length <= 1) {
+            return [];
+        }
+        return FAM_TsChunker_Util.packClassUnits(units, block, sizing, classHeadingPath);
+    }
+    /**
+     * A class-blokk member-egységekre bontása (FAM-REV-049): az első unit a class-FEJ (JSDoc + signature a
+     * body-nyitásig), majd a class-body memberei a brace-depth member-határai mentén (egy member zár, ha a
+     * body-szintre [depth 1] tér vissza, VAGY egy `;`-re végződő egy-soros field). Brace-depth (NEM AST).
+     */
+    static parseClassUnits(block) {
+        const lines = block.lines;
+        // (1) class-body nyitás: az első sor, ahol a kumulált brace-depth >= 1.
+        let depth = 0;
+        let openIdx = -1;
+        for (let i = 0; i < lines.length; i++) {
+            depth += FAM_TsChunker_Util.countBraces(lines[i]);
+            if (depth >= 1) {
+                openIdx = i;
+                break;
+            }
+        }
+        if (openIdx < 0) {
+            return [];
+        }
+        const units = [];
+        units.push({ lines: lines.slice(0, openIdx + 1), lineOffset: 0, isMethod: false });
+        // (2) a body memberei (depth 1-ről indulva).
+        let current = [];
+        let currentStart = openIdx + 1;
+        let bodyDepth = 1;
+        for (let i = openIdx + 1; i < lines.length; i++) {
+            const line = lines[i];
+            const before = bodyDepth;
+            bodyDepth += FAM_TsChunker_Util.countBraces(line);
+            if (bodyDepth <= 0) {
+                // class-záró `}` → a maradékot flush-öljük (a záró brace-sort nem külön chunkoljuk).
+                if (current.length) {
+                    units.push(FAM_TsChunker_Util.makeMemberUnit(current, currentStart));
+                }
+                break;
+            }
+            if (!current.length) {
+                currentStart = i;
+            }
+            current.push(line);
+            const closedBackToBody = before > 1 && bodyDepth === 1; // braced member (metódus) lezárult
+            const oneLineField = before === 1 && bodyDepth === 1 && line.trim().endsWith(';');
+            if (closedBackToBody || oneLineField) {
+                units.push(FAM_TsChunker_Util.makeMemberUnit(current, currentStart));
+                current = [];
+            }
+        }
+        return units;
+    }
+    /** Egy member-sortömb → `FAM_ClassUnit` (a signature-sorból kinyert metódus-névvel). */
+    static makeMemberUnit(lines, lineOffset) {
+        const sigLine = lines.find((line) => {
+            const trimmed = line.trim();
+            return trimmed.length > 0
+                && !trimmed.startsWith('/*') && !trimmed.startsWith('*') && !trimmed.startsWith('//')
+                && !trimmed.startsWith('@');
+        }) ?? '';
+        const match = sigLine.trim().match(FAM_TsChunker_Util.METHOD_SIG);
+        const isMethod = !!match && sigLine.includes('(');
+        return { lines: lines, lineOffset: lineOffset, name: match ? match[1] : undefined, isMethod: isMethod };
+    }
+    /**
+     * A member-egységek chunkokra csomagolása (FAM-REV-049): minSize-ig akkumulál (semmi ne essen ki a
+     * zaj-szűrőn), maxSize előtt flush-öl; az adekvát egy-metódusú chunk `method:`-symbol-láncot + `'method'`
+     * típust kap, a többi (class-fej / field-csoport) a `'class'` típust + a class-symbol-láncot. A maxSize
+     * feletti egyetlen member soros sliding-window-ra bomlik (örökölt symbol-lánc).
+     */
+    static packClassUnits(units, block, sizing, classHeadingPath) {
+        // Sor-kezdő char-offsetek a class-blokkon belül (a pontos charStart-hoz).
+        const lineCharOffset = [];
+        let acc = 0;
+        for (let i = 0; i < block.lines.length; i++) {
+            lineCharOffset[i] = acc;
+            acc += block.lines[i].length + 1;
+        }
+        const chunks = [];
+        let group = [];
+        const groupText = () => group.map((unit) => unit.lines.join('\n')).join('\n');
+        const flush = () => {
+            if (!group.length) {
+                return;
+            }
+            const text = groupText();
+            if (text.trim().length) {
+                const first = group[0];
+                const last = group[group.length - 1];
+                const lastLineOffset = last.lineOffset + last.lines.length - 1;
+                const single = group.length === 1 && first.isMethod && !!first.name;
+                const baseChar = block.charStart + (lineCharOffset[first.lineOffset] ?? 0);
+                chunks.push({
+                    content: text,
+                    position: {
+                        charStart: baseChar,
+                        charEnd: baseChar + text.length,
+                        lineStart: block.lineStart + first.lineOffset,
+                        lineEnd: block.lineStart + lastLineOffset,
+                    },
+                    chunkType: single ? 'method' : 'class',
+                    headingPath: single ? [...classHeadingPath, `method:${first.name}`] : classHeadingPath,
+                });
+            }
+            group = [];
+        };
+        for (const unit of units) {
+            const unitText = unit.lines.join('\n');
+            // Túl nagy egyetlen member → flush + soros sliding (örökölt method/class symbol-lánc).
+            if (unitText.length > sizing.maxSize) {
+                flush();
+                const headPath = unit.isMethod && unit.name
+                    ? [...classHeadingPath, `method:${unit.name}`]
+                    : classHeadingPath;
+                chunks.push(...FAM_TsChunker_Util.slidingWindowLines({
+                    lines: unit.lines,
+                    charStart: block.charStart + (lineCharOffset[unit.lineOffset] ?? 0),
+                    lineStart: block.lineStart + unit.lineOffset,
+                    sizing: sizing,
+                    headingPath: headPath,
+                    chunkType: unit.isMethod ? 'method' : 'class',
+                }));
+                continue;
+            }
+            // maxSize-túllépés a csoporttal → előbb flush.
+            if (group.length && (groupText().length + 1 + unitText.length) > sizing.maxSize) {
+                flush();
+            }
+            group.push(unit);
+            // Elérte a minSize-t → flush (az adekvát metódus így a SAJÁT chunkja marad).
+            if (groupText().trim().length >= sizing.minSize) {
+                flush();
+            }
+        }
+        flush();
+        return chunks;
+    }
     /** A symbol-`headingPath` egy blokkhoz (`['class:Foo']`); generic / névtelen → üres tömb. */
     static buildHeadingPath(block) {
         if (block.entityName && block.blockType !== 'generic' && block.blockType !== 'imports') {

package/build/src/_modules/ingest/_services/fam-delta-compare.util.js

@@ -51,7 +51,10 @@ class FAM_DeltaCompare_Util {
             }
             matchedIndices.add(chunk.chunkIndex);
             if (existingEntry.contentHash === contentHash) {
-                items.push({ verdict: 'equal', chunk: chunk, existingId: existingEntry._id, contentHash: contentHash });
+                items.push({
+                    verdict: 'equal', chunk: chunk, existingId: existingEntry._id, contentHash: contentHash,
+                    existingEmbeddingStatus: existingEntry.embeddingStatus, // FAM-REV-066: a re-embed-if-not-completed-hez
+                });
             }
             else {
                 items.push({ verdict: 'modified', chunk: chunk, existingId: existingEntry._id, contentHash: contentHash });

package/build/src/_modules/ingest/_services/fam-ingest-run.data-service.js

@@ -31,13 +31,16 @@ class FAM_IngestRun_DataService extends nts_dynamo_1.DyNTS_DataService {
         return new nts_dynamo_1.DyNTS_ArchiveDataService(new fam_ingest_run_data_model_1.FAM_IngestRun_DataModel(), this.dataParams, this.issuer);
     }
     /**
-     * A run megnyitása a scan ELEJÉN (dsgn-004 §5). A `_id` = a hívó által generált runId (UUID v4),
-     * hogy a chunkok az `ingestRunId`-vel HIVATKOZHASSANAK rá MÉG a run-zárás előtt. Friss `saveData`
-     * (új rekord — nincs Mixed-mutáció). A számlálók/verdiktek a `close`-ban frissülnek.
+     * A run megnyitása a scan ELEJÉN (dsgn-004 §5). A `_id`-t a Dynamo `saveData` GENERÁLJA (Mongo
+     * ObjectId, stringként) — a `FAM_Scope` mintáját követve (`findOrCreateScope`). **NEM** állítunk
+     * client-generált UUID `_id`-t: a Dynamo db-rétege a get-by-id-t `findById`-dal végzi, ami a `_id`-t
+     * ObjectId-ra cast-olja → egy UUID-string cast-ja elhasal (`DyNTS-DBS-GI0`). A hívó a VISSZAADOTT
+     * rekord `_id`-jét használja runId-ként (a chunkok ezzel az `ingestRunId`-vel hivatkoznak rá MÉG a
+     * run-zárás előtt). Friss `saveData` (új rekord — nincs Mixed-mutáció); a számlálók/verdiktek a
+     * `close`-ban frissülnek.
      */
     async open(set) {
         const record = new fam_ingest_run_data_model_1.FAM_IngestRun_DataModel({
-            _id: set.runId,
             trigger: set.trigger,
             table: set.table,
             scopePath: set.scopePath,