@futdevpro/nts-dynamo 1.15.105 → 1.15.110

package/src/_modules/ai/_modules/ai-mock/_collections/aim-fixture-match.util.ts

@@ -0,0 +1,60 @@
+import * as crypto from 'crypto';
+
+import { DyNTS_AIMock_Request } from '../_models/interfaces/aim-request.interface';
+
+/**
+ * A fixture-match kulcs DETERMINISZTIKUS képzése. Cél: azonos „jelentésű" request → azonos kulcs,
+ * függetlenül a config-kulcsok sorrendjétől és az input whitespace-variánsaitól (különben false
+ * reject-on-unknown, l. HYPERPLAN D3 + MP-3 SP-3.1). NEM végez generálást — tiszta, hálózat-mentes.
+ */
+export class DyNTS_AIMock_FixtureMatch_Util {
+  /**
+   * A teljes match-kulcs: `provider|model|modality|<config-hash>|<input-hash>`.
+   * @param request - a mock-hívás bemenete
+   */
+  static buildMatchKey(request: DyNTS_AIMock_Request): string {
+    const configHash: string = this.hash(this.canonicalizeConfig(request.config ?? {}));
+    const inputHash: string = this.buildInputHash(request.input);
+
+    return `${request.provider}|${request.model}|${request.modality}|${configHash}|${inputHash}`;
+  }
+
+  /**
+   * Csak az input-hash (a `DyNTS_AIMock_Fixture.inputHash`-hez): a kanonizált input SHA-256-ja.
+   * @param input - a modalitás-függő bemenet
+   */
+  static buildInputHash(input: unknown): string {
+    return this.hash(this.canonicalizeInput(input));
+  }
+
+  /**
+   * Kulcs-rendezett, stabil szöveg egy config-objektumból (a config-kulcsok sorrend-függetlenségéhez).
+   * Megjegyzés: a nested-objektum mély-kanonizációja jövőbeli finomítás (a shallow key-sort a config-flat
+   * paramétereket — temperature/dimensions/size — fedi).
+   * @param config - a kanonizálandó config
+   */
+  private static canonicalizeConfig(config: Record<string, unknown>): string {
+    const sortedKeys: string[] = Object.keys(config).sort();
+    const parts: string[] = sortedKeys.map((key: string) => `${key}:${JSON.stringify(config[key])}`);
+
+    return parts.join('|');
+  }
+
+  /**
+   * Input-kanonizáció: string → trim + belső whitespace-összevonás; egyéb (pl. embedding-szöveg-tömb) →
+   * stabil JSON (a sorrend jelentős, pl. batch-embedding).
+   * @param input - a bemenet
+   */
+  private static canonicalizeInput(input: unknown): string {
+    if (typeof input === 'string') {
+      return input.trim().replace(/\s+/g, ' ');
+    }
+
+    return JSON.stringify(input);
+  }
+
+  /** SHA-256 hex az adott szövegből. */
+  private static hash(value: string): string {
+    return crypto.createHash('sha256').update(value).digest('hex');
+  }
+}

package/src/_modules/ai/_modules/ai-mock/_collections/aim-fixture-serializer.util.spec.ts

@@ -0,0 +1,56 @@
+import { DyNTS_AIMock_Modality } from '../_enums/aim-modality.enum';
+import { DyNTS_AIMock_Fixture } from '../_models/interfaces/aim-fixture.interface';
+import { DyNTS_AIMock_FixtureSerializer_Util } from './aim-fixture-serializer.util';
+
+describe('| DyNTS_AIMock_FixtureSerializer_Util', () => {
+
+  function fixture(model: string, inputHash: string): DyNTS_AIMock_Fixture {
+    return {
+      provider: 'open-ai',
+      model: model,
+      modality: DyNTS_AIMock_Modality.text,
+      input: 'ping',
+      inputHash: inputHash,
+      output: 'pong',
+      capturedAt: '2026-07-21T00:00:00.000Z',
+    };
+  }
+
+  it('| determinisztikus: a fixture-ok SORRENDJETOL fuggetlenul azonos kimenet', () => {
+    const a: DyNTS_AIMock_Fixture[] = [ fixture('m-b', 'h2'), fixture('m-a', 'h1') ];
+    const b: DyNTS_AIMock_Fixture[] = [ fixture('m-a', 'h1'), fixture('m-b', 'h2') ];
+
+    const first: string = DyNTS_AIMock_FixtureSerializer_Util.toConstantFile({ constName: 'X', fixtures: a });
+    const second: string = DyNTS_AIMock_FixtureSerializer_Util.toConstantFile({ constName: 'X', fixtures: b });
+
+    expect(first).toBe(second);
+  });
+
+  it('| az objektum-kulcsok abc-sorrendben jonnek ki (stabil diff)', () => {
+    const output: string = DyNTS_AIMock_FixtureSerializer_Util.toConstantFile({
+      constName: 'X',
+      fixtures: [ fixture('m-a', 'h1') ],
+    });
+
+    expect(output.indexOf('"capturedAt"')).toBeLessThan(output.indexOf('"input"'));
+    expect(output.indexOf('"input"')).toBeLessThan(output.indexOf('"model"'));
+    expect(output.indexOf('"model"')).toBeLessThan(output.indexOf('"provider"'));
+  });
+
+  it('| valid TS-konstans vazat ad (import + export const + tipus)', () => {
+    const output: string = DyNTS_AIMock_FixtureSerializer_Util.toConstantFile({
+      constName: 'DyNTS_AIMock_TestFixtures',
+      fixtures: [ fixture('m-a', 'h1') ],
+    });
+
+    expect(output).toContain(`from '@futdevpro/nts-dynamo/ai/ai-mock'`);
+    expect(output).toContain('export const DyNTS_AIMock_TestFixtures: DyNTS_AIMock_Fixture[] = [');
+    expect(output.trim().endsWith('];')).toBe(true);
+  });
+
+  it('| ures keszlet → ures tomb-literal', () => {
+    const output: string = DyNTS_AIMock_FixtureSerializer_Util.toConstantFile({ constName: 'X', fixtures: [] });
+
+    expect(output).toContain('export const X: DyNTS_AIMock_Fixture[] = [');
+  });
+});

package/src/_modules/ai/_modules/ai-mock/_collections/aim-fixture-serializer.util.ts

@@ -0,0 +1,107 @@
+import { DyNTS_AIMock_Fixture } from '../_models/interfaces/aim-fixture.interface';
+
+/**
+ * Beegetett fixture-ok **determinisztikus** TS-konstans fajlla alakitasa (D6: git-tracked, NEM env-fuggo).
+ *
+ * A determinizmus itt nem kozmetika: a fixture-fajlok verziokezeltek, ezert ugyanaz a fixture-keszlet
+ * MINDIG ugyanazt a fajl-tartalmat kell adja — kulonben minden ujra-generalas zajos diff-et okoz, es a
+ * code-review hasznalhatatlanna valik. Ezert: a fixture-ok **match-kulcs szerint rendezve**, az objektum-
+ * kulcsok pedig **rekurzivan abc-sorrendben** kerulnek ki.
+ */
+export class DyNTS_AIMock_FixtureSerializer_Util {
+
+  /** Behuzas egy szintje. */
+  private static readonly indentUnit: string = '  ';
+
+  /**
+   * Fixture-tomb → teljes TS-konstans fajl tartalma (import + export const + JSDoc-fejlec).
+   * @param set - a konstans neve + a fixture-ok + opcionalis fejlec-megjegyzes
+   */
+  static toConstantFile(
+    set: {
+      constName: string,
+      fixtures: DyNTS_AIMock_Fixture[],
+      headerNote?: string,
+    }
+  ): string {
+    const sorted: DyNTS_AIMock_Fixture[] = this.sortFixtures(set.fixtures);
+    const body: string = sorted
+      .map((fixture: DyNTS_AIMock_Fixture) => this.stringify(fixture, this.indentUnit))
+      .join(',\n');
+
+    const note: string = set.headerNote ?? 'Auto-generalt fixture-keszlet — kezzel NE szerkeszd.';
+
+    return [
+      `import { DyNTS_AIMock_Fixture } from '@futdevpro/nts-dynamo/ai/ai-mock';`,
+      '',
+      '/**',
+      ` * ${note}`,
+      ' *',
+      ' * Determinisztikus sorrend (match-kulcs szerint) + rendezett objektum-kulcsok, hogy az ujra-generalas',
+      ' * ne okozzon zajos diff-et. Forras: `DyNTS_AIMock_FixtureSerializer_Util`.',
+      ' */',
+      `export const ${set.constName}: DyNTS_AIMock_Fixture[] = [`,
+      body,
+      '];',
+      '',
+    ].join('\n');
+  }
+
+  /** Fixture-ok stabil rendezese (provider|model|modality|inputHash). */
+  private static sortFixtures(fixtures: DyNTS_AIMock_Fixture[]): DyNTS_AIMock_Fixture[] {
+    return [ ...fixtures ].sort((a: DyNTS_AIMock_Fixture, b: DyNTS_AIMock_Fixture) => {
+      return this.sortKeyOf(a).localeCompare(this.sortKeyOf(b));
+    });
+  }
+
+  /** A rendezesi kulcs egy fixture-hoz. */
+  private static sortKeyOf(fixture: DyNTS_AIMock_Fixture): string {
+    return `${fixture.provider}|${fixture.model}|${fixture.modality}|${fixture.inputHash}`;
+  }
+
+  /**
+   * Rekurziv, kulcs-rendezett stringify (a `JSON.stringify` a beszurasi sorrendet tartana meg — az nem stabil).
+   * @param value - a szerializalando ertek
+   * @param indent - az aktualis behuzas
+   */
+  private static stringify(value: unknown, indent: string): string {
+    if (value === null || value === undefined) {
+      return `${indent}null`;
+    }
+
+    if (Array.isArray(value)) {
+      if (!value.length) {
+        return `${indent}[]`;
+      }
+      const items: string = value
+        .map((item: unknown) => this.stringify(item, indent + this.indentUnit))
+        .join(',\n');
+
+      return `${indent}[\n${items}\n${indent}]`;
+    }
+
+    if (typeof value === 'object') {
+      // `Object.entries` a generikus `object`-en is mukodik → nincs szukseg `as`-castra.
+      const source: Map<string, unknown> = new Map(Object.entries(value));
+      const keys: string[] = [ ...source.keys() ]
+        .filter((key: string) => source.get(key) !== undefined)
+        .sort();
+
+      if (!keys.length) {
+        return `${indent}{}`;
+      }
+
+      const entries: string = keys
+        .map((key: string) => {
+          const rendered: string = this.stringify(source.get(key), indent + this.indentUnit).trimStart();
+
+          return `${indent}${this.indentUnit}${JSON.stringify(key)}: ${rendered}`;
+        })
+        .join(',\n');
+
+      return `${indent}{\n${entries}\n${indent}}`;
+    }
+
+    return `${indent}${JSON.stringify(value)}`;
+  }
+}

package/src/_modules/ai/_modules/ai-mock/_enums/aim-modality.enum.ts

@@ -0,0 +1,15 @@
+/**
+ * Az AI-mock által kezelt modalitások. A mock MINDEN modalitásra ugyanazt a replay / reject-on-unknown
+ * viselkedést adja (l. `documentations/plans/ai-mocking-system/HYPERPLAN.md` D3). A `value` a beégetett
+ * fixture-ök + a match-kulcs modality-szegmense.
+ */
+export enum DyNTS_AIMock_Modality {
+  /** Szöveg-completion (chat / LLM). */
+  text = 'text',
+  /** Embedding-vektor kimenet. */
+  embedding = 'embedding',
+  /** Kép-generálás (base64 kimenet). */
+  image = 'image',
+  /** Hang: transcription (audio→szöveg) vagy TTS (szöveg→base64-audio). */
+  audio = 'audio',
+}

package/src/_modules/ai/_modules/ai-mock/_models/interfaces/aim-call-input.interface.ts

@@ -0,0 +1,14 @@
+/**
+ * Egy mock modalitás-hívás bemenete — a modalitást a hívott metódus adja (`chatCompletion` → text stb.),
+ * ezért itt NINCS `modality` mező (v.ö. `DyNTS_AIMock_Request`, ami a teljes match-kulcs bemenete).
+ */
+export interface DyNTS_AIMock_CallInput {
+  /** Provider-azonosító (pl. 'open-ai'). */
+  provider: string;
+  /** Pontos API modell-azonosító (pl. 'gpt-4o-mini'). */
+  model: string;
+  /** Provider-specifikus config-paraméterek. */
+  config?: Record<string, unknown>;
+  /** Modalitás-függő bemenet. */
+  input: unknown;
+}

package/src/_modules/ai/_modules/ai-mock/_models/interfaces/aim-error.interface.ts

@@ -0,0 +1,11 @@
+import { DyNTS_AI_ProviderError } from '../../../../_models/interfaces/dynts-ai-provider-error.interface';
+
+/**
+ * Provider-faithful hiba egy fixture-höz — a mock UGYANEZT reprodukálja, mintha a valódi provider dobná
+ * (pl. reasoning-modell + `temperature` → OpenAI HTTP 400 `unsupported_parameter`).
+ *
+ * **Alias** a modul-szintű `DyNTS_AI_ProviderError`-ra (SSoT): a Layer A validátor
+ * (`DyNTS_AI_ModelConfig_Validator`) és a Layer B fixture-ök UGYANAZT a hiba-alakot használják — nincs
+ * párhuzamos shape. A név megmarad, hogy az ai-mock oldali olvashatóság ne romoljon.
+ */
+export type DyNTS_AIMock_Error = DyNTS_AI_ProviderError;

package/src/_modules/ai/_modules/ai-mock/_models/interfaces/aim-fixture.interface.ts

@@ -0,0 +1,30 @@
+import { DyNTS_AIMock_Modality } from '../../_enums/aim-modality.enum';
+import { DyNTS_AIMock_Error } from './aim-error.interface';
+
+/**
+ * Egy beégetett fixture-rekord (git-tracked konstans, D6). Az `output` XOR `error` közül PONTOSAN egy van:
+ * sikeres válasz VAGY provider-faithful hiba. Az `inputHash` a normalizált match-kulcs input-szegmense
+ * (l. `DyNTS_AIMock_FixtureMatch_Util.buildInputHash`). A `capturedAt` / `sourceModel` audit-nyomvonal (D4).
+ */
+export interface DyNTS_AIMock_Fixture {
+  /** Provider-azonosító. */
+  provider: string;
+  /** Pontos API modell-azonosító. */
+  model: string;
+  /** A fixture modalitása. */
+  modality: DyNTS_AIMock_Modality;
+  /** A rögzített config-paraméterek (a match-kulcs része). */
+  config?: Record<string, unknown>;
+  /** A normalizált input-hash (deterministic input→fixture feloldáshoz). */
+  inputHash: string;
+  /** A nyers bemenet (ember-olvasható referencia; a match az `inputHash`-en megy). */
+  input: unknown;
+  /** Sikeres kimenet (modalitás-függő). Az `error`-ral kölcsönösen kizáró. */
+  output?: unknown;
+  /** Provider-faithful hiba. Az `output`-tal kölcsönösen kizáró. */
+  error?: DyNTS_AIMock_Error;
+  /** A beégetés időbélyege (ISO). */
+  capturedAt: string;
+  /** A tényleges generáló modell (ha eltér a kért aliastól). */
+  sourceModel?: string;
+}

package/src/_modules/ai/_modules/ai-mock/_models/interfaces/aim-request.interface.ts

@@ -0,0 +1,19 @@
+import { DyNTS_AIMock_Modality } from '../../_enums/aim-modality.enum';
+
+/**
+ * Egy mock-hívás bemenete — EBBŐL képződik a fixture-match kulcs (`DyNTS_AIMock_FixtureMatch_Util`).
+ * A `config` a provider-specifikus hívás-paraméterek (a FR-048 `settingsSchema` ellen validálandó), az
+ * `input` modalitás-függő (prompt-szöveg / embedding-szöveg(ek) / kép-prompt / audio-referencia).
+ */
+export interface DyNTS_AIMock_Request {
+  /** Provider-azonosító (pl. 'open-ai', 'anthropic', 'fdp-ai'). */
+  provider: string;
+  /** Pontos API modell-azonosító (pl. 'gpt-4o-mini'). */
+  model: string;
+  /** A hívás modalitása. */
+  modality: DyNTS_AIMock_Modality;
+  /** Provider-specifikus config-paraméterek (temperature / dimensions / size / …). */
+  config?: Record<string, unknown>;
+  /** Modalitás-függő bemenet (prompt / szövegek / kép-prompt / audio-ref). */
+  input: unknown;
+}

package/src/_modules/ai/_modules/ai-mock/_models/interfaces/aim-service-collection.interface.ts

@@ -0,0 +1,20 @@
+import { DyFM_AI_ModelInfo } from '@futdevpro/fsm-dynamo/ai';
+
+import { DyNTS_AIMock_FixtureStore_Service } from '../../_services/aim-fixture-store.service';
+import { DyNTS_AIMock_Service } from '../../_services/aim-mock.service';
+
+/**
+ * Egy kesz, osszedrotozott AI-mock keszlet (`getDefaultAiMockServiceCollection` kimenete): a fixture-tar,
+ * a ra epulo mock-provider, es a config-validaciohoz bekototott modell-registry.
+ *
+ * A `store` azert is publikus, hogy a teszt futas kozben tovabbi fixture-oket regisztralhasson
+ * (`store.register([...])`) anelkul, hogy ujra kellene epiteni a kollekciot.
+ */
+export interface DyNTS_AIMock_ServiceCollection {
+  /** A beegetett fixture-ok tara (futas kozben bovitheto). */
+  store: DyNTS_AIMock_FixtureStore_Service;
+  /** A mock provider-surface (chat / embedding / image / audio). */
+  service: DyNTS_AIMock_Service;
+  /** A bekototott modell-registry — ebbol jon a FR-048 `settingsSchema`-alapu config-validacio. */
+  registry: DyFM_AI_ModelInfo[];
+}

package/src/_modules/ai/{_services → _modules/ai-mock/_services}/ai-embedding-mock.service.spec.ts

@@ -5,7 +5,7 @@ import {
   DyNTS_AI_Embedding_MockService,
   DyNTS_AI_MOCK_EMBEDDING_DIMS,
 } from './ai-embedding-mock.service';
-import { DyNTS_AI_CostEvent } from '../_models/interfaces/dynts-ai-cost-event.interface';
+import { DyNTS_AI_CostEvent } from '../../../_models/interfaces/dynts-ai-cost-event.interface';
 
 describe('| DyNTS_AI_Embedding_MockService', () => {
 

package/src/_modules/ai/{_services → _modules/ai-mock/_services}/ai-embedding-mock.service.ts

@@ -4,8 +4,8 @@ import { CreateEmbeddingResponse } from 'openai/resources';
 import { DyFM_AI_Provider, DyFM_AI_ProviderCapabilities, DyFM_AI_Config } from '@futdevpro/fsm-dynamo/ai';
 import { DyFM_DAI_EmbeddingInfo } from '@futdevpro/fsm-dynamo/ai/document-ai';
 
-import { DyNTS_AI_CostEventCallback } from '../_models/interfaces/dynts-ai-cost-event-callback.interface';
-import { DyNTS_AI_Embedding_ServiceBase } from './ai-embedding.service-base';
+import { DyNTS_AI_CostEventCallback } from '../../../_models/interfaces/dynts-ai-cost-event-callback.interface';
+import { DyNTS_AI_Embedding_ServiceBase } from '../../../_services/ai-embedding.service-base';
 
 /** A mock-embedding default dimenziója (kicsi, hogy a teszt-pool gyors legyen, de elég a koszinuszhoz). */
 export const DyNTS_AI_MOCK_EMBEDDING_DIMS: number = 64;

package/src/_modules/ai/_modules/ai-mock/_services/aim-fixture-harness.service.spec.ts

@@ -0,0 +1,134 @@
+import { DyFM_Error } from '@futdevpro/fsm-dynamo';
+import { DyFM_AI_ModelInfo, DyFM_AI_ModelType, DyFM_AI_Provider } from '@futdevpro/fsm-dynamo/ai';
+
+import { DyNTS_AIMock_Modality } from '../_enums/aim-modality.enum';
+import { DyNTS_AIMock_Request } from '../_models/interfaces/aim-request.interface';
+import { DyNTS_AIMock_Fixture } from '../_models/interfaces/aim-fixture.interface';
+import { DyNTS_AIMock_FixtureHarness_Service } from './aim-fixture-harness.service';
+
+describe('| DyNTS_AIMock_FixtureHarness_Service (MP-3 SP-3.2)', () => {
+
+  const registry: DyFM_AI_ModelInfo[] = [
+    {
+      id: 'cheap-mini',
+      provider: DyFM_AI_Provider.OpenAI,
+      modelType: DyFM_AI_ModelType.Chat,
+      tier: 'mini',
+      capabilities: {} as any,
+    },
+    {
+      id: 'expensive-pro',
+      provider: DyFM_AI_Provider.OpenAI,
+      modelType: DyFM_AI_ModelType.Chat,
+      tier: 'pro',
+      capabilities: {} as any,
+    },
+    {
+      id: 'expensive-opus',
+      provider: DyFM_AI_Provider.Anthropic,
+      modelType: DyFM_AI_ModelType.Chat,
+      tier: 'Opus',
+      capabilities: {} as any,
+    },
+  ];
+
+  /** Stub-generator, ami JELZI, ha meghivtak — igy bizonyithato, hogy a zarak MEG a hivas elott fognak. */
+  function makeStub(): { calls: number, generate: (request: DyNTS_AIMock_Request) => Promise<unknown> } {
+    const state: { calls: number, generate: (request: DyNTS_AIMock_Request) => Promise<unknown> } = {
+      calls: 0,
+      generate: async (): Promise<unknown> => {
+        state.calls++;
+
+        return 'generated-output';
+      },
+    };
+
+    return state;
+  }
+
+  function request(model: string): DyNTS_AIMock_Request {
+    return {
+      provider: 'open-ai',
+      model: model,
+      modality: DyNTS_AIMock_Modality.text,
+      config: { maxTokens: 10 },
+      input: 'ping',
+    };
+  }
+
+  it('| spend-guard ALAPBOL kikapcsolt → nem general, ES a generatort MEG CSAK NEM IS hivja', async () => {
+    const stub = makeStub();
+    const harness: DyNTS_AIMock_FixtureHarness_Service = new DyNTS_AIMock_FixtureHarness_Service({
+      generator: stub.generate,
+      registry: registry,
+    });
+
+    try {
+      await harness.capture(request('cheap-mini'));
+      fail('spend-guard hibat vartunk');
+    } catch (error) {
+      expect(error instanceof DyFM_Error).toBe(true);
+      if (error instanceof DyFM_Error) {
+        expect(error.message).toContain('spend-guard');
+      }
+    }
+
+    expect(stub.calls).toBe(0);
+  });
+
+  it('| D2 tier-cap: `pro` tier elutasitva, a generator nem hivodik', async () => {
+    const stub = makeStub();
+    const harness: DyNTS_AIMock_FixtureHarness_Service = new DyNTS_AIMock_FixtureHarness_Service({
+      generator: stub.generate,
+      registry: registry,
+      allowRealSpend: true,
+    });
+
+    await expectAsync(harness.capture(request('expensive-pro'))).toBeRejected();
+    expect(stub.calls).toBe(0);
+  });
+
+  it('| D2 tier-cap: `Opus` tier elutasitva (kis/nagybetu-fuggetlen)', async () => {
+    const stub = makeStub();
+    const harness: DyNTS_AIMock_FixtureHarness_Service = new DyNTS_AIMock_FixtureHarness_Service({
+      generator: stub.generate,
+      registry: registry,
+      allowRealSpend: true,
+    });
+
+    await expectAsync(harness.capture(request('expensive-opus'))).toBeRejected();
+    expect(stub.calls).toBe(0);
+  });
+
+  it('| registry-ben nem szereplo modell → elutasitva (a tier nem igazolhato)', async () => {
+    const stub = makeStub();
+    const harness: DyNTS_AIMock_FixtureHarness_Service = new DyNTS_AIMock_FixtureHarness_Service({
+      generator: stub.generate,
+      registry: registry,
+      allowRealSpend: true,
+    });
+
+    await expectAsync(harness.capture(request('nincs-ilyen'))).toBeRejected();
+    expect(stub.calls).toBe(0);
+  });
+
+  it('| engedelyezett spend + olcso tier → fixture keszul, helyes mezokkel', async () => {
+    const stub = makeStub();
+    const harness: DyNTS_AIMock_FixtureHarness_Service = new DyNTS_AIMock_FixtureHarness_Service({
+      generator: stub.generate,
+      registry: registry,
+      allowRealSpend: true,
+      nowIso: (): string => '2026-07-21T00:00:00.000Z',
+    });
+
+    const fixture: DyNTS_AIMock_Fixture = await harness.capture(request('cheap-mini'));
+
+    expect(stub.calls).toBe(1);
+    expect(fixture.output).toBe('generated-output');
+    expect(fixture.model).toBe('cheap-mini');
+    expect(fixture.modality).toBe(DyNTS_AIMock_Modality.text);
+    expect(fixture.capturedAt).toBe('2026-07-21T00:00:00.000Z');
+    expect(fixture.sourceModel).toBe('cheap-mini');
+    expect(fixture.inputHash.length).toBeGreaterThan(0);
+  });
+});

package/src/_modules/ai/_modules/ai-mock/_services/aim-fixture-harness.service.ts

@@ -0,0 +1,127 @@
+import { DyFM_Error } from '@futdevpro/fsm-dynamo';
+import { DyFM_AI_ModelInfo, DyFM_AI_ModelRegistry_Util } from '@futdevpro/fsm-dynamo/ai';
+
+import { DyNTS_AIMock_Request } from '../_models/interfaces/aim-request.interface';
+import { DyNTS_AIMock_Fixture } from '../_models/interfaces/aim-fixture.interface';
+import { DyNTS_AIMock_FixtureMatch_Util } from '../_collections/aim-fixture-match.util';
+
+/**
+ * A D2 kolseg-cap altal TILTOTT modell-tier-ek (kisbetusen hasonlitva).
+ *
+ * Forras — a FR (`USER-INPUT.md`, 2026-06-22): „nem megyunk el a legmagasabb szintu modellekig, illetve nem
+ * megyunk el peldaul OpenAI Pro modellekig, de az alap, default es mini mikro modelleket szeretnem".
+ * Ezert tiltott: `pro` (gpt-5.5-pro / o3-pro / gemini-pro), `opus` (claude-opus), `flagship` (a legmagasabb
+ * szintu alap-modell). Engedett: mini / nano / legacy / flash / flash-lite / sonnet / haiku.
+ */
+const D2_BLOCKED_TIERS: string[] = [ 'pro', 'opus', 'flagship' ];
+
+/**
+ * **Fixture-generalo harness** (MP-3 SP-3.2) — VALODI provider-valaszbol keszit beegetheto fixture-t.
+ *
+ * **Ket egymastol fuggetlen biztonsagi zar, mert ez az egyetlen pont, ahol valodi PENZ folyhat el:**
+ * 1. **Spend-guard** — az `allowRealSpend` alapertelmezese `false`. Amig nincs EXPLICIT bekapcsolva, a harness
+ *    **el sem hivja** az injektalt generatort. Igy meg egy veletlenul bekototott valodi generator sem tud
+ *    hivast inditani. (G1 kapu: a bekapcsolas user-jovahagyashoz kotott.)
+ * 2. **D2 tier-cap** — a Pro / Opus / flagship tier-u modelleket elutasitja MEG a generator hivasa elott.
+ *
+ * A generator INJEKTALT (`(request) => Promise<unknown>`), ezert a harness maga soha nem fuggo halozattol —
+ * a tesztek stub-generatorral futnak, valodi hivas nelkul.
+ */
+export class DyNTS_AIMock_FixtureHarness_Service {
+
+  /** A valodi (vagy stub) generalo fuggveny — a harness NEM tud halozatot hivni sajat maga. */
+  private readonly generator: (request: DyNTS_AIMock_Request) => Promise<unknown>;
+
+  /** Modell-registry a tier-cap ellenorzeshez. */
+  private readonly registry: DyFM_AI_ModelInfo[];
+
+  /** Spend-guard: amig `false`, a generator NEM hivodik meg. Default: `false`. */
+  private readonly allowRealSpend: boolean;
+
+  /** Tiltott tier-ek (default: a D2 keszlet). */
+  private readonly blockedTiers: string[];
+
+  /** ISO-timestamp forras (injektalhato a determinisztikus tesztekhez). */
+  private readonly nowIso: () => string;
+
+  /**
+   * @param set - generator + registry + a ket biztonsagi zar beallitasa.
+   */
+  constructor(
+    set: {
+      generator: (request: DyNTS_AIMock_Request) => Promise<unknown>,
+      registry?: DyFM_AI_ModelInfo[],
+      /** CSAK explicit `true` eseten hivodik meg a generator (G1). Default: `false`. */
+      allowRealSpend?: boolean,
+      blockedTiers?: string[],
+      nowIso?: () => string,
+    }
+  ) {
+    this.generator = set.generator;
+    this.registry = set.registry ?? [];
+    this.allowRealSpend = set.allowRealSpend === true;
+    this.blockedTiers = set.blockedTiers ?? D2_BLOCKED_TIERS;
+    this.nowIso = set.nowIso ?? ((): string => new Date().toISOString());
+  }
+
+  /**
+   * Egy fixture rogzitese valodi generalasbol. A ket zar sorrendje: spend-guard → tier-cap → generator.
+   * @param request - a rogzitendo hivas (provider + model + modality + config + input)
+   */
+  async capture(request: DyNTS_AIMock_Request): Promise<DyNTS_AIMock_Fixture> {
+    this.assertSpendAllowed(request);
+    this.assertTierAllowed(request);
+
+    const output: unknown = await this.generator(request);
+
+    return {
+      provider: request.provider,
+      model: request.model,
+      modality: request.modality,
+      config: request.config,
+      input: request.input,
+      inputHash: DyNTS_AIMock_FixtureMatch_Util.buildInputHash(request.input),
+      output: output,
+      capturedAt: this.nowIso(),
+      sourceModel: request.model,
+    };
+  }
+
+  /** 1. zar — a spend-guard. */
+  private assertSpendAllowed(request: DyNTS_AIMock_Request): void {
+    if (this.allowRealSpend) {
+      return;
+    }
+
+    throw new DyFM_Error({
+      message: `[ai-mock] real generation is DISABLED (spend-guard). Model '${request.provider}:${request.model}'. ` +
+        'Set allowRealSpend=true only with explicit approval (G1 gate).',
+      userMessage: 'Real AI generation is disabled.',
+      errorCode: 'DyNTS-AIMOCK-SPEND',
+    });
+  }
+
+  /** 2. zar — a D2 tier-cap. Ismeretlen modell (nincs registry-ben) → NEM engedjuk (honesty). */
+  private assertTierAllowed(request: DyNTS_AIMock_Request): void {
+    const modelInfo: DyFM_AI_ModelInfo = DyFM_AI_ModelRegistry_Util.findModelInfo(this.registry, request.model);
+    const tier: string = (modelInfo?.tier ?? '').toLowerCase();
+
+    if (!modelInfo) {
+      throw new DyFM_Error({
+        message: `[ai-mock] model '${request.model}' is not in the registry — tier cannot be verified, ` +
+          'refusing to generate (D2 cost-cap, honesty).',
+        userMessage: 'Unknown AI model for fixture generation.',
+        errorCode: 'DyNTS-AIMOCK-TIER',
+      });
+    }
+
+    if (this.blockedTiers.includes(tier)) {
+      throw new DyFM_Error({
+        message: `[ai-mock] model '${request.model}' has blocked tier '${modelInfo.tier}' (D2 cost-cap: ` +
+          `${this.blockedTiers.join(', ')}). Use a mini/nano/flash tier model for fixtures.`,
+        userMessage: 'This AI model tier is not allowed for fixture generation.',
+        errorCode: 'DyNTS-AIMOCK-TIER',
+      });
+    }
+  }
+}