agentic-qe 3.11.4 → 3.12.0

package/dist/learning/qe-flywheel/receipt-store.js

@@ -0,0 +1,89 @@
+/**
+ * Durable, append-only persistence for flywheel evolve receipts (ADR-118 §4).
+ *
+ * The generational lineage is only trustworthy if it survives the process: a
+ * third party must be able to reload the receipts and re-verify each one
+ * (signature + frozen-gate re-execution) offline. This stores every receipt —
+ * promoted OR rejected — in an append-only table in the unified `memory.db`.
+ *
+ * Data safety (unified-memory rule): CREATE TABLE IF NOT EXISTS is additive;
+ * writes are INSERT-only (no UPDATE/DELETE/DROP in this API); the caller opens
+ * the DB and is responsible for backups. The `db` handle is injected so tests
+ * run against an in-memory database.
+ */
+import { reconstructLineage } from './generation.js';
+/** Idempotent, additive migration — creates the receipts table if absent. */
+export function ensureReceiptTable(db) {
+    db.exec(`
+    CREATE TABLE IF NOT EXISTS flywheel_receipts (
+      seq                 INTEGER PRIMARY KEY AUTOINCREMENT,
+      generation          INTEGER NOT NULL,
+      rule_version        TEXT NOT NULL,
+      rule_fingerprint    TEXT NOT NULL,
+      sealed_hash         TEXT NOT NULL,
+      sealed_json         TEXT NOT NULL,
+      verdict             TEXT NOT NULL,
+      baseline_policy_id  TEXT NOT NULL,
+      candidate_policy_id TEXT NOT NULL,
+      signer_key_id       TEXT NOT NULL,
+      public_key_pem      TEXT NOT NULL,
+      signature           TEXT NOT NULL,
+      created_at          TEXT DEFAULT (datetime('now'))
+    )
+  `);
+}
+/** Append one receipt (INSERT-only). Returns its assigned seq. */
+export function persistReceipt(db, receipt) {
+    ensureReceiptTable(db);
+    const info = db.prepare(`
+    INSERT INTO flywheel_receipts
+      (generation, rule_version, rule_fingerprint, sealed_hash, sealed_json,
+       verdict, baseline_policy_id, candidate_policy_id, signer_key_id,
+       public_key_pem, signature)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+  `).run(receipt.generation, receipt.ruleVersion, receipt.ruleFingerprint, receipt.sealedHash, JSON.stringify(receipt.sealed), receipt.verdict, receipt.baselinePolicyId, receipt.candidatePolicyId, receipt.signerKeyId, receipt.publicKeyPem, receipt.signature);
+    return Number(info.lastInsertRowid);
+}
+/** Append many receipts in one transaction (still INSERT-only). */
+export function persistReceipts(db, receipts) {
+    ensureReceiptTable(db);
+    const tx = db.transaction((rs) => {
+        for (const r of rs)
+            persistReceipt(db, r);
+    });
+    tx(receipts);
+    return receipts.length;
+}
+/** Load persisted receipts back into EvolveReceipt objects, ordered by seq. */
+export function loadReceipts(db) {
+    ensureReceiptTable(db);
+    const rows = db.prepare(`
+    SELECT generation, rule_version, rule_fingerprint, sealed_hash, sealed_json,
+           verdict, baseline_policy_id, candidate_policy_id, signer_key_id,
+           public_key_pem, signature
+      FROM flywheel_receipts
+     ORDER BY seq ASC
+  `).all();
+    return rows.map((r) => ({
+        generation: r.generation,
+        ruleVersion: r.rule_version,
+        ruleFingerprint: r.rule_fingerprint,
+        sealed: JSON.parse(r.sealed_json),
+        sealedHash: r.sealed_hash,
+        verdict: r.verdict === 'promote' ? 'promote' : 'reject',
+        baselinePolicyId: r.baseline_policy_id,
+        candidatePolicyId: r.candidate_policy_id,
+        signerKeyId: r.signer_key_id,
+        publicKeyPem: r.public_key_pem,
+        signature: r.signature,
+    }));
+}
+/**
+ * Reload the persisted lineage and re-verify it end-to-end (signatures +
+ * frozen-gate re-execution + compounding chain). This is the offline
+ * "trust the re-run, not the log" check applied to what's actually on disk.
+ */
+export function verifyPersistedLineage(db) {
+    return reconstructLineage(loadReceipts(db));
+}
+//# sourceMappingURL=receipt-store.js.map

package/dist/learning/qe-flywheel/receipt.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Ed25519-signed evolve receipts for the QE-policy flywheel (ADR-118 §4).
+ *
+ * Every generation — promoted OR rejected — emits a signed receipt into an
+ * append-only lineage. A receipt seals the decision inputs (composing ADR-116 /
+ * ADR-120) and signs the whole body, so a third party can (a) re-execute the
+ * frozen rule on the sealed inputs (ADR-120 verifyPromotion) and (b) verify the
+ * signature — trusting the SIGNATURE and the RE-RUN, not the producer.
+ *
+ * Ed25519 via Node's built-in crypto — dependency-free (ADR-118 §6).
+ */
+import type { SealedInputs, PromotionReceipt } from '../../validation/gate-reexecute.js';
+export interface Signer {
+    /** Stable id for the signing key (hash of the public key). */
+    keyId: string;
+    /** SPKI PEM of the public key — travels in the receipt for verification. */
+    publicKeyPem: string;
+    /** Sign a message, returning a hex signature. */
+    sign(message: string): string;
+}
+/**
+ * Create an Ed25519 signer. With a 32-byte seed (hex or Buffer) the keypair is
+ * DETERMINISTIC — same seed ⇒ same key ⇒ reproducible receipts (useful for
+ * replay bundles and tests). Without a seed, a fresh random keypair is used.
+ */
+export declare function createSigner(seed?: string | Buffer): Signer;
+/** Verify an Ed25519 signature against a public key PEM. Never throws. */
+export declare function verifySignature(publicKeyPem: string, message: string, signatureHex: string): boolean;
+/** A signed evolve receipt — the durable, verifiable record of one generation. */
+export interface EvolveReceipt {
+    generation: number;
+    /** Frozen acceptance rule this decision used (ADR-120). */
+    ruleVersion: string;
+    ruleFingerprint: string;
+    /** Sealed decision inputs + their content hash (ADR-116/120). */
+    sealed: SealedInputs;
+    sealedHash: string;
+    /** The verdict this generation recorded. */
+    verdict: 'promote' | 'reject';
+    /** Lineage links: which policy was the baseline, which the candidate. */
+    baselinePolicyId: string;
+    candidatePolicyId: string;
+    /** Signer identity + public key (for offline verification). */
+    signerKeyId: string;
+    publicKeyPem: string;
+    /** Ed25519 signature over the canonical receipt body. */
+    signature: string;
+}
+/** The signed portion of a receipt (everything except the signature itself). */
+export type ReceiptBody = Omit<EvolveReceipt, 'signature'>;
+/** Canonical serialization of the receipt body for signing/verifying. */
+export declare function receiptBodyString(body: ReceiptBody): string;
+/** Sign a receipt body, producing a complete signed receipt. */
+export declare function signReceipt(body: ReceiptBody, signer: Signer): EvolveReceipt;
+/** Verify a receipt's Ed25519 signature (does NOT re-execute the gate — see ADR-120). */
+export declare function verifyReceiptSignature(receipt: EvolveReceipt): boolean;
+/**
+ * Adapt an EvolveReceipt to the ADR-120 PromotionReceipt shape so it can be
+ * re-verified by `verifyPromotion` (maps `verdict` → `recordedVerdict`).
+ */
+export declare function toPromotionReceipt(receipt: EvolveReceipt): PromotionReceipt;
+//# sourceMappingURL=receipt.d.ts.map

package/dist/learning/qe-flywheel/receipt.js

@@ -0,0 +1,97 @@
+/**
+ * Ed25519-signed evolve receipts for the QE-policy flywheel (ADR-118 §4).
+ *
+ * Every generation — promoted OR rejected — emits a signed receipt into an
+ * append-only lineage. A receipt seals the decision inputs (composing ADR-116 /
+ * ADR-120) and signs the whole body, so a third party can (a) re-execute the
+ * frozen rule on the sealed inputs (ADR-120 verifyPromotion) and (b) verify the
+ * signature — trusting the SIGNATURE and the RE-RUN, not the producer.
+ *
+ * Ed25519 via Node's built-in crypto — dependency-free (ADR-118 §6).
+ */
+import { generateKeyPairSync, createPrivateKey, createPublicKey, sign as edSign, verify as edVerify, createHash, } from 'node:crypto';
+/** Derive a stable key id from a public key PEM. */
+function keyIdOf(publicKeyPem) {
+    return createHash('sha256').update(publicKeyPem).digest('hex').slice(0, 16);
+}
+/**
+ * Create an Ed25519 signer. With a 32-byte seed (hex or Buffer) the keypair is
+ * DETERMINISTIC — same seed ⇒ same key ⇒ reproducible receipts (useful for
+ * replay bundles and tests). Without a seed, a fresh random keypair is used.
+ */
+export function createSigner(seed) {
+    let privateKey;
+    let publicKey;
+    if (seed !== undefined) {
+        const raw = typeof seed === 'string' ? Buffer.from(seed, 'hex') : seed;
+        if (raw.length !== 32) {
+            throw new Error(`Ed25519 seed must be 32 bytes (got ${raw.length}).`);
+        }
+        // PKCS#8 wrapper for a raw Ed25519 seed: fixed 16-byte prefix + 32-byte seed.
+        const pkcs8 = Buffer.concat([
+            Buffer.from('302e020100300506032b657004220420', 'hex'),
+            raw,
+        ]);
+        privateKey = createPrivateKey({ key: pkcs8, format: 'der', type: 'pkcs8' });
+        publicKey = createPublicKey(privateKey);
+    }
+    else {
+        ({ privateKey, publicKey } = generateKeyPairSync('ed25519'));
+    }
+    const publicKeyPem = publicKey.export({ format: 'pem', type: 'spki' }).toString();
+    return {
+        keyId: keyIdOf(publicKeyPem),
+        publicKeyPem,
+        sign(message) {
+            return edSign(null, Buffer.from(message, 'utf8'), privateKey).toString('hex');
+        },
+    };
+}
+/** Verify an Ed25519 signature against a public key PEM. Never throws. */
+export function verifySignature(publicKeyPem, message, signatureHex) {
+    try {
+        const publicKey = createPublicKey(publicKeyPem);
+        return edVerify(null, Buffer.from(message, 'utf8'), publicKey, Buffer.from(signatureHex, 'hex'));
+    }
+    catch {
+        return false;
+    }
+}
+/** Canonical serialization of the receipt body for signing/verifying. */
+export function receiptBodyString(body) {
+    // Field order is fixed here (not sorted) so it is explicit and stable.
+    return JSON.stringify({
+        generation: body.generation,
+        ruleVersion: body.ruleVersion,
+        ruleFingerprint: body.ruleFingerprint,
+        sealedHash: body.sealedHash,
+        verdict: body.verdict,
+        baselinePolicyId: body.baselinePolicyId,
+        candidatePolicyId: body.candidatePolicyId,
+        signerKeyId: body.signerKeyId,
+    });
+}
+/** Sign a receipt body, producing a complete signed receipt. */
+export function signReceipt(body, signer) {
+    const signature = signer.sign(receiptBodyString(body));
+    return { ...body, signature };
+}
+/** Verify a receipt's Ed25519 signature (does NOT re-execute the gate — see ADR-120). */
+export function verifyReceiptSignature(receipt) {
+    const { signature, ...body } = receipt;
+    return verifySignature(receipt.publicKeyPem, receiptBodyString(body), signature);
+}
+/**
+ * Adapt an EvolveReceipt to the ADR-120 PromotionReceipt shape so it can be
+ * re-verified by `verifyPromotion` (maps `verdict` → `recordedVerdict`).
+ */
+export function toPromotionReceipt(receipt) {
+    return {
+        ruleVersion: receipt.ruleVersion,
+        ruleFingerprint: receipt.ruleFingerprint,
+        sealedHash: receipt.sealedHash,
+        sealed: receipt.sealed,
+        recordedVerdict: receipt.verdict,
+    };
+}
+//# sourceMappingURL=receipt.js.map

package/dist/learning/qe-reasoning-bank.js

@@ -343,16 +343,12 @@ export class QEReasoningBank {
         if (!this.config.enableLearning) {
             return ok(undefined);
         }
-        const result = await this.patternStore.recordUsage(outcome.patternId, outcome.success);
-        // Persist usage to SQLite (updates qe_patterns row AND inserts qe_pattern_usage)
-        try {
-            const store = this.getSqliteStore();
-            store.recordUsage(outcome.patternId, outcome.success, outcome.metrics, outcome.feedback);
-        }
-        catch (persistError) {
-            // Non-critical — don't fail if persistence fails
-            logger.warn('SQLite pattern usage persist failed', { error: toErrorMessage(persistError) });
-        }
+        // Single writer (#486 Gap B): patternStore.recordUsage() persists to SQLite
+        // itself (updates qe_patterns row AND inserts qe_pattern_usage) when a
+        // SQLitePatternStore is wired via setSqliteStore(). A second explicit
+        // SQLite write here previously double-counted every outcome — two
+        // qe_pattern_usage rows and a +2 usage_count for one recordOutcome() call.
+        const result = await this.patternStore.recordUsage(outcome.patternId, outcome.success, outcome.metrics, outcome.feedback);
         if (result.success) {
             this.stats.learningOutcomes++;
             if (outcome.success) {
@@ -608,9 +604,18 @@ export class QEReasoningBank {
         // DB fallback (#454): in-memory `this.stats` is reset on every process
         // start, but every hook invocation spawns a fresh node. Without a DB
         // fallback, `aqe hooks stats` always reports zeros even when historical
-        // routing_outcomes / qe_pattern_usage rows exist. We use the in-memory
-        // counters when they're non-zero (live, current-process data), otherwise
-        // fall back to aggregated DB totals.
+        // routing_outcomes / qe_pattern_usage rows exist.
+        //
+        // routing_outcomes / qe_pattern_usage are written synchronously on every
+        // recordOutcome()/routeTask() call, so the DB aggregate is always a
+        // superset of (>=) the in-memory counters for this process. Previously
+        // this only consulted the DB when the in-memory counter was exactly
+        // zero, which made reported totals regress the moment in-memory ticked
+        // past zero mid-session — a cold-start call would correctly report the
+        // historical DB total, then the very next call after one recordOutcome()
+        // would drop to reporting just "1" instead of "historical total + 1".
+        // Taking the max keeps the number monotonic while still tolerating a
+        // failed/unavailable DB aggregate (falls back to in-memory).
         let routingRequests = this.stats.routingRequests;
         let avgRoutingConfidence = this.stats.routingRequests > 0
             ? this.stats.totalRoutingConfidence / this.stats.routingRequests
@@ -619,27 +624,25 @@ export class QEReasoningBank {
         let patternSuccessRate = this.stats.learningOutcomes > 0
             ? this.stats.successfulOutcomes / this.stats.learningOutcomes
             : 0;
-        if (routingRequests === 0 || learningOutcomes === 0) {
-            try {
-                const agg = this.getSqliteStore().getAggregateOutcomeStats();
-                if (routingRequests === 0 && agg.routingRequests > 0) {
-                    routingRequests = agg.routingRequests;
-                    avgRoutingConfidence = agg.avgRoutingConfidence;
-                }
-                if (learningOutcomes === 0 && agg.learningOutcomes > 0) {
-                    learningOutcomes = agg.learningOutcomes;
-                    // Prefer per-usage success rate (closer to recordOutcome semantics);
-                    // fall back to qe_patterns.success_rate aggregate when no usage rows.
-                    patternSuccessRate =
-                        agg.learningOutcomes > 0
-                            ? agg.successfulOutcomes / agg.learningOutcomes
-                            : agg.avgPatternSuccessRate;
-                }
+        try {
+            const agg = this.getSqliteStore().getAggregateOutcomeStats();
+            if (agg.routingRequests > routingRequests) {
+                routingRequests = agg.routingRequests;
+                avgRoutingConfidence = agg.avgRoutingConfidence;
             }
-            catch {
-                // best-effort — never let stats reporting crash the host
+            if (agg.learningOutcomes > learningOutcomes) {
+                learningOutcomes = agg.learningOutcomes;
+                // Prefer per-usage success rate (closer to recordOutcome semantics);
+                // fall back to qe_patterns.success_rate aggregate when no usage rows.
+                patternSuccessRate =
+                    agg.learningOutcomes > 0
+                        ? agg.successfulOutcomes / agg.learningOutcomes
+                        : agg.avgPatternSuccessRate;
             }
         }
+        catch {
+            // best-effort — never let stats reporting crash the host
+        }
         return {
             totalPatterns: patternStoreStats.totalPatterns,
             byDomain,

package/dist/learning/routing-topology-gate.d.ts

@@ -20,8 +20,18 @@
  *    permanently dampened in the exact deployment case ADR-095 was meant
  *    to help.
  *
- * Treat empty/uninitialized graph as "no signal" (full ε rate). Only
- * consult `isCritical()` when the graph has actual vertices.
+ *    A16 correction (2026-07-06): `graph.isEmpty()` alone doesn't catch
+ *    this — `QueenMinCutBridge` always seeds ~14 `domain:*` scaffold
+ *    vertices + workflow edges on init, so `isEmpty()` is false as soon as
+ *    Queen starts, even with zero real agents ever spawned. The mincut
+ *    over those scaffold-only edges (one-directional, `defect-intelligence`
+ *    a pure sink) computes to exactly 0.0 — still degenerate, still
+ *    "critical" by the threshold check. Check for real `agent:*` vertices
+ *    specifically (same fix `QueenMinCutBridge.isEmptyTopology()` already
+ *    applies internally), not raw vertex count.
+ *
+ * Treat a graph with no real agent vertices as "no signal" (full ε rate).
+ * Only consult `isCritical()` once at least one agent has actually spawned.
  */
 /**
  * Returns true ONLY when:

package/dist/learning/routing-topology-gate.js

@@ -20,8 +20,18 @@
  *    permanently dampened in the exact deployment case ADR-095 was meant
  *    to help.
  *
- * Treat empty/uninitialized graph as "no signal" (full ε rate). Only
- * consult `isCritical()` when the graph has actual vertices.
+ *    A16 correction (2026-07-06): `graph.isEmpty()` alone doesn't catch
+ *    this — `QueenMinCutBridge` always seeds ~14 `domain:*` scaffold
+ *    vertices + workflow edges on init, so `isEmpty()` is false as soon as
+ *    Queen starts, even with zero real agents ever spawned. The mincut
+ *    over those scaffold-only edges (one-directional, `defect-intelligence`
+ *    a pure sink) computes to exactly 0.0 — still degenerate, still
+ *    "critical" by the threshold check. Check for real `agent:*` vertices
+ *    specifically (same fix `QueenMinCutBridge.isEmptyTopology()` already
+ *    applies internally), not raw vertex count.
+ *
+ * Treat a graph with no real agent vertices as "no signal" (full ε rate).
+ * Only consult `isCritical()` once at least one agent has actually spawned.
  */
 import { getSharedMinCutGraph, getSharedMinCutMonitor, isSharedMinCutGraphInitialized, isSharedMinCutMonitorInitialized, } from '../coordination/mincut/shared-singleton.js';
 /**
@@ -44,7 +54,9 @@ export function resolveTopologyCriticalFromSharedMincut() {
         if (!isSharedMinCutGraphInitialized())
             return false;
         const graph = getSharedMinCutGraph();
-        if (graph.isEmpty())
+        // Domain-coordinator scaffold vertices/edges are always present once
+        // Queen initializes; they don't count as "the graph has real signal".
+        if (graph.getVerticesByType('agent').length === 0)
             return false;
         return getSharedMinCutMonitor().isCritical();
     }

package/dist/learning/rvf-pattern-store.d.ts

@@ -63,7 +63,7 @@ export declare class RvfPatternStore implements IPatternStore {
     create(options: CreateQEPatternOptions): Promise<Result<QEPattern>>;
     get(id: string): Promise<QEPattern | null>;
     search(query: string | number[], options?: PatternSearchOptions): Promise<Result<PatternSearchResult[]>>;
-    recordUsage(id: string, success: boolean): Promise<Result<void>>;
+    recordUsage(id: string, success: boolean, metrics?: Record<string, unknown>, feedback?: string): Promise<Result<void>>;
     promote(id: string): Promise<Result<void>>;
     delete(id: string): Promise<Result<void>>;
     getStats(): Promise<PatternStoreStats>;

package/dist/learning/rvf-pattern-store.js

@@ -372,12 +372,12 @@ export class RvfPatternStore {
     // --------------------------------------------------------------------------
     // IPatternStore — Mutation operations
     // --------------------------------------------------------------------------
-    async recordUsage(id, success) {
+    async recordUsage(id, success, metrics, feedback) {
         if (!this.sqliteStore) {
             return err(new Error('No SQLite store attached'));
         }
         try {
-            this.sqliteStore.recordUsage(id, success);
+            this.sqliteStore.recordUsage(id, success, metrics, feedback);
             return ok(undefined);
         }
         catch (error) {
@@ -419,18 +419,31 @@ export class RvfPatternStore {
     }
     async getStats() {
         const rvfStatus = this.adapter?.status();
-        // Get pattern count from RVF if available, otherwise fall back to SQLite
-        let totalPatterns = rvfStatus?.totalVectors ?? 0;
-        if (totalPatterns === 0 && this.sqliteStore) {
+        // qe_patterns (SQLite) is the source of truth for pattern count and
+        // domain/tier breakdown — the RVF vector index only covers patterns
+        // that have actually been embedded, and is reported separately via
+        // hnswStats.vectorCount. Previously this used RVF's totalVectors as the
+        // headline count, which silently hid any pattern stored without a
+        // matching embedding (#553).
+        let totalPatterns = 0;
+        let byDomain = {};
+        let byTier = { shortTerm: 0, longTerm: 0 };
+        if (this.sqliteStore) {
             try {
-                totalPatterns = this.sqliteStore.getStats().totalPatterns;
+                const sqliteStats = this.sqliteStore.getStats();
+                totalPatterns = sqliteStats.totalPatterns;
+                byDomain = sqliteStats.byDomain;
+                byTier = {
+                    shortTerm: sqliteStats.byTier['short-term'] ?? 0,
+                    longTerm: sqliteStats.byTier['long-term'] ?? 0,
+                };
             }
             catch { /* best effort */ }
         }
         return {
             totalPatterns,
-            byTier: { shortTerm: 0, longTerm: 0 },
-            byDomain: {},
+            byTier,
+            byDomain,
             byType: {},
             avgConfidence: 0,
             avgQualityScore: 0,

package/dist/learning/sqlite-persistence.js

@@ -391,24 +391,27 @@ export class SQLitePatternStore {
         if (!insertPattern || !insertEmbedding) {
             throw new Error('Prepared statements not ready');
         }
+        let actualId = id;
         // Use transaction for atomicity
         const transaction = this.db.transaction(() => {
             insertPattern.run(id, pattern.patternType, pattern.qeDomain, pattern.domain, pattern.name, pattern.description || '', pattern.confidence, pattern.tier || 'short-term', JSON.stringify(pattern.template), JSON.stringify(pattern.context));
+            // #447: ON CONFLICT(name, qe_domain, pattern_type) preserves the
+            // existing row's id instead of `id`. Resolve the actual id BEFORE
+            // inserting the embedding — qe_pattern_embeddings.pattern_id has a
+            // FOREIGN KEY on qe_patterns(id), so inserting under the discarded
+            // `id` (no such row) throws "FOREIGN KEY constraint failed".
+            const actualRow = this.db
+                .prepare('SELECT id FROM qe_patterns WHERE name = ? AND qe_domain = ? AND pattern_type = ?')
+                .get(pattern.name, pattern.qeDomain ?? '', pattern.patternType ?? '');
+            actualId = actualRow ? actualRow.id : id;
             if (embedding) {
                 // Store embedding as BLOB (Float32Array)
                 const buffer = Buffer.from(new Float32Array(embedding).buffer);
-                insertEmbedding.run(id, buffer, embedding.length, 'all-MiniLM-L6-v2');
+                insertEmbedding.run(actualId, buffer, embedding.length, 'all-MiniLM-L6-v2');
             }
         });
         transaction();
-        // #447: ON CONFLICT(name, qe_domain, pattern_type) preserves the existing
-        // row's id, so the new `id` we just tried to insert may not be what's
-        // actually stored. SELECT the actual id back so callers (rvf-pattern-store,
-        // qe-hooks) can stay consistent with HNSW and downstream usage tables.
-        const actualRow = this.db
-            .prepare('SELECT id FROM qe_patterns WHERE name = ? AND qe_domain = ? AND pattern_type = ?')
-            .get(pattern.name, pattern.qeDomain ?? '', pattern.patternType ?? '');
-        return actualRow ? actualRow.id : id;
+        return actualId;
     }
     /**
      * Get a pattern by ID