agentic-qe 3.8.11 → 3.8.13

package/dist/integrations/ruvector/temporal-causality.js

@@ -0,0 +1,317 @@
+/**
+ * Granger Causality for Test Failure Prediction (R12, ADR-087 Milestone 4)
+ *
+ * Temporal causal discovery: finds causal chains between test failures.
+ * E.g. "when test_login fails, test_checkout fails 5min later at 87%."
+ *
+ * Algorithm: Bivariate VAR(p) + F-test with OLS via Gaussian elimination
+ * and regularized incomplete beta function for F-distribution CDF.
+ *
+ * @module integrations/ruvector/temporal-causality
+ */
+const DEFAULT_CONFIG = { maxLag: 5, alpha: 0.05, minSeriesLength: 30 };
+const BETA_CF_MAX_ITER = 200;
+const BETA_CF_EPS = 1e-10;
+const OLS_EPS = 1e-12;
+// -- Statistical math: lnGamma, incomplete beta, F-distribution CDF ---------
+/** Lanczos approximation of ln(Gamma(z)). */
+function lnGamma(z) {
+    if (z <= 0)
+        return Infinity;
+    const c = [0.99999999999980993, 676.5203681218851, -1259.1392167224028,
+        771.32342877765313, -176.61502916214059, 12.507343278686905,
+        -0.13857109526572012, 9.9843695780195716e-6, 1.5056327351493116e-7];
+    if (z < 0.5)
+        return Math.log(Math.PI / Math.sin(Math.PI * z)) - lnGamma(1 - z);
+    z -= 1;
+    let x = c[0];
+    for (let i = 1; i < 9; i++)
+        x += c[i] / (z + i);
+    const t = z + 7.5;
+    return 0.5 * Math.log(2 * Math.PI) + (z + 0.5) * Math.log(t) - t + Math.log(x);
+}
+function lnBeta(a, b) {
+    return lnGamma(a) + lnGamma(b) - lnGamma(a + b);
+}
+/** Regularized incomplete beta I_x(a,b) via continued fraction (Lentz). */
+function regularizedIncompleteBeta(x, a, b) {
+    if (x <= 0)
+        return 0;
+    if (x >= 1)
+        return 1;
+    if (a <= 0 || b <= 0)
+        return NaN;
+    if (x > (a + 1) / (a + b + 2))
+        return 1 - regularizedIncompleteBeta(1 - x, b, a);
+    const front = Math.exp(a * Math.log(x) + b * Math.log(1 - x) - lnBeta(a, b) - Math.log(a));
+    let c = 1, d = 1 - (a + b) * x / (a + 1);
+    if (Math.abs(d) < BETA_CF_EPS)
+        d = BETA_CF_EPS;
+    d = 1 / d;
+    let f = d;
+    for (let m = 1; m <= BETA_CF_MAX_ITER; m++) {
+        let num = m * (b - m) * x / ((a + 2 * m - 1) * (a + 2 * m));
+        d = 1 + num * d;
+        if (Math.abs(d) < BETA_CF_EPS)
+            d = BETA_CF_EPS;
+        c = 1 + num / c;
+        if (Math.abs(c) < BETA_CF_EPS)
+            c = BETA_CF_EPS;
+        d = 1 / d;
+        f *= c * d;
+        num = -(a + m) * (a + b + m) * x / ((a + 2 * m) * (a + 2 * m + 1));
+        d = 1 + num * d;
+        if (Math.abs(d) < BETA_CF_EPS)
+            d = BETA_CF_EPS;
+        c = 1 + num / c;
+        if (Math.abs(c) < BETA_CF_EPS)
+            c = BETA_CF_EPS;
+        d = 1 / d;
+        const delta = c * d;
+        f *= delta;
+        if (Math.abs(delta - 1) < BETA_CF_EPS)
+            break;
+    }
+    return front * f;
+}
+/** F-distribution CDF via incomplete beta: P(F<=x) = I_{d1*x/(d1*x+d2)}(d1/2, d2/2) */
+function fDistributionCDF(x, d1, d2) {
+    if (x <= 0)
+        return 0;
+    if (d1 <= 0 || d2 <= 0)
+        return NaN;
+    if (!isFinite(x))
+        return 1;
+    return regularizedIncompleteBeta((d1 * x) / (d1 * x + d2), d1 / 2, d2 / 2);
+}
+// -- OLS Regression ---------------------------------------------------------
+/** Solve A*x = b via Gaussian elimination with partial pivoting. */
+function solveLinearSystem(A, b) {
+    const n = b.length;
+    const aug = A.map((row, i) => [...row, b[i]]);
+    for (let col = 0; col < n; col++) {
+        let maxVal = Math.abs(aug[col][col]), maxRow = col;
+        for (let row = col + 1; row < n; row++) {
+            const v = Math.abs(aug[row][col]);
+            if (v > maxVal) {
+                maxVal = v;
+                maxRow = row;
+            }
+        }
+        if (maxVal < OLS_EPS)
+            return null;
+        if (maxRow !== col)
+            [aug[col], aug[maxRow]] = [aug[maxRow], aug[col]];
+        for (let row = col + 1; row < n; row++) {
+            const f = aug[row][col] / aug[col][col];
+            for (let j = col; j <= n; j++)
+                aug[row][j] -= f * aug[col][j];
+        }
+    }
+    const x = new Array(n).fill(0);
+    for (let row = n - 1; row >= 0; row--) {
+        if (Math.abs(aug[row][row]) < OLS_EPS)
+            return null;
+        let sum = aug[row][n];
+        for (let j = row + 1; j < n; j++)
+            sum -= aug[row][j] * x[j];
+        x[row] = sum / aug[row][row];
+    }
+    return x;
+}
+/** OLS: beta = (X'X)^{-1} X'y via normal equations. */
+function olsRegression(X, y) {
+    const n = y.length, p = X[0].length;
+    const XtX = Array.from({ length: p }, () => new Array(p).fill(0));
+    for (let i = 0; i < p; i++) {
+        for (let j = i; j < p; j++) {
+            let s = 0;
+            for (let k = 0; k < n; k++)
+                s += X[k][i] * X[k][j];
+            XtX[i][j] = s;
+            XtX[j][i] = s;
+        }
+    }
+    const Xty = new Array(p).fill(0);
+    for (let i = 0; i < p; i++) {
+        let s = 0;
+        for (let k = 0; k < n; k++)
+            s += X[k][i] * y[k];
+        Xty[i] = s;
+    }
+    return solveLinearSystem(XtX, Xty);
+}
+/** Residual sum of squares for y = X * beta. */
+function computeRSS(X, y, beta) {
+    let rss = 0;
+    for (let i = 0; i < y.length; i++) {
+        let pred = 0;
+        for (let j = 0; j < beta.length; j++)
+            pred += X[i][j] * beta[j];
+        const r = y[i] - pred;
+        rss += r * r;
+    }
+    return rss;
+}
+// -- Time series alignment --------------------------------------------------
+/** Align two series to a common time grid (nearest-neighbor binning). */
+function alignTimeSeries(source, target) {
+    const minT = Math.max(source.timestamps[0] ?? Infinity, target.timestamps[0] ?? Infinity);
+    const maxT = Math.min(source.timestamps[source.timestamps.length - 1] ?? -Infinity, target.timestamps[target.timestamps.length - 1] ?? -Infinity);
+    if (minT >= maxT)
+        return null;
+    const intervals = [];
+    for (const ts of [source, target])
+        for (let i = 1; i < ts.timestamps.length; i++) {
+            const dt = ts.timestamps[i] - ts.timestamps[i - 1];
+            if (dt > 0)
+                intervals.push(dt);
+        }
+    if (intervals.length === 0)
+        return null;
+    intervals.sort((a, b) => a - b);
+    const bin = intervals[Math.floor(intervals.length / 2)];
+    if (bin <= 0)
+        return null;
+    const nBins = Math.floor((maxT - minT) / bin) + 1;
+    if (nBins < 2)
+        return null;
+    const srcOut = new Array(nBins).fill(0);
+    const tgtOut = new Array(nBins).fill(0);
+    for (const [series, out] of [[source, srcOut], [target, tgtOut]]) {
+        for (let i = 0; i < series.timestamps.length; i++) {
+            const b = Math.round((series.timestamps[i] - minT) / bin);
+            if (b >= 0 && b < nBins)
+                out[b] = series.outcomes[i];
+        }
+    }
+    return { sourceOutcomes: srcOut, targetOutcomes: tgtOut };
+}
+// -- Granger Analyzer -------------------------------------------------------
+export class GrangerAnalyzer {
+    config;
+    constructor(config) {
+        this.config = { ...DEFAULT_CONFIG, ...config };
+    }
+    /** Analyze all pairs; returns only significant links (p < alpha). */
+    analyzeCausality(timeSeries) {
+        if (timeSeries.length < 2)
+            return [];
+        const links = [];
+        for (let i = 0; i < timeSeries.length; i++) {
+            for (let j = 0; j < timeSeries.length; j++) {
+                if (i === j)
+                    continue;
+                const src = timeSeries[i], tgt = timeSeries[j];
+                if (src.outcomes.length < this.config.minSeriesLength ||
+                    tgt.outcomes.length < this.config.minSeriesLength)
+                    continue;
+                let best = null;
+                for (let lag = 1; lag <= this.config.maxLag; lag++) {
+                    const link = this.testPairwise(src, tgt, lag);
+                    if (this.significanceTest(link) && (best === null || link.pValue < best.pValue))
+                        best = link;
+                }
+                if (best)
+                    links.push(best);
+            }
+        }
+        links.sort((a, b) => a.pValue - b.pValue);
+        return links;
+    }
+    /** Test Granger causality for one pair at one lag via VAR(p) + F-test. */
+    testPairwise(source, target, lag) {
+        const def = {
+            sourceTestId: source.testId, targetTestId: target.testId,
+            lag, fStatistic: 0, pValue: 1, strength: 0, direction: 'positive',
+        };
+        let srcData, tgtData;
+        if (this.arraysEqual(source.timestamps, target.timestamps)) {
+            srcData = source.outcomes;
+            tgtData = target.outcomes;
+        }
+        else {
+            const a = alignTimeSeries(source, target);
+            if (!a)
+                return def;
+            srcData = a.sourceOutcomes;
+            tgtData = a.targetOutcomes;
+        }
+        const n = tgtData.length, effN = n - lag, dfDenom = effN - 2 * lag - 1;
+        if (dfDenom <= 0 || effN < this.config.minSeriesLength)
+            return def;
+        const y = new Array(effN);
+        for (let t = 0; t < effN; t++)
+            y[t] = tgtData[t + lag];
+        const yMean = y.reduce((s, v) => s + v, 0) / y.length;
+        if (y.reduce((s, v) => s + (v - yMean) ** 2, 0) < OLS_EPS)
+            return def;
+        // Restricted: [intercept, Y(t-1)..Y(t-lag)]
+        const Xr = new Array(effN);
+        for (let t = 0; t < effN; t++) {
+            const row = new Array(lag + 1);
+            row[0] = 1;
+            for (let k = 1; k <= lag; k++)
+                row[k] = tgtData[t + lag - k];
+            Xr[t] = row;
+        }
+        // Unrestricted: [intercept, Y lags, X lags]
+        const Xu = new Array(effN);
+        for (let t = 0; t < effN; t++) {
+            const row = new Array(2 * lag + 1);
+            row[0] = 1;
+            for (let k = 1; k <= lag; k++)
+                row[k] = tgtData[t + lag - k];
+            for (let k = 1; k <= lag; k++)
+                row[lag + k] = srcData[t + lag - k];
+            Xu[t] = row;
+        }
+        const betaR = olsRegression(Xr, y);
+        if (!betaR)
+            return def;
+        const rssR = computeRSS(Xr, y, betaR);
+        const betaU = olsRegression(Xu, y);
+        if (!betaU)
+            return def;
+        const rssU = computeRSS(Xu, y, betaU);
+        if (rssU > rssR)
+            return def; // Numerical noise
+        const num = (rssR - rssU) / lag;
+        const den = rssU / dfDenom;
+        const srcCoeffs = betaU.slice(lag + 1, 2 * lag + 1);
+        const strength = srcCoeffs.reduce((s, c) => s + Math.abs(c), 0) / lag;
+        const avgCoeff = srcCoeffs.reduce((s, c) => s + c, 0) / lag;
+        const dir = avgCoeff >= 0 ? 'positive' : 'negative';
+        if (den < OLS_EPS) {
+            const fS = num > OLS_EPS ? 1e6 : 0;
+            return { ...def, fStatistic: fS, pValue: fS > 0 ? 0 : 1, strength, direction: dir };
+        }
+        const fStat = num / den;
+        const pValue = 1 - fDistributionCDF(fStat, lag, dfDenom);
+        return {
+            sourceTestId: source.testId, targetTestId: target.testId, lag,
+            fStatistic: Math.max(0, fStat),
+            pValue: Math.max(0, Math.min(1, pValue)),
+            strength, direction: dir,
+        };
+    }
+    /** True if the link is statistically significant at the configured alpha. */
+    significanceTest(link) {
+        return link.pValue < this.config.alpha && link.fStatistic > 0;
+    }
+    arraysEqual(a, b) {
+        if (a.length !== b.length)
+            return false;
+        for (let i = 0; i < a.length; i++)
+            if (a[i] !== b[i])
+                return false;
+        return true;
+    }
+}
+// -- Factory ----------------------------------------------------------------
+export function createGrangerAnalyzer(config) {
+    return new GrangerAnalyzer(config);
+}
+// -- Exported internals for testing -----------------------------------------
+export { regularizedIncompleteBeta as _regularizedIncompleteBeta, fDistributionCDF as _fDistributionCDF, lnGamma as _lnGamma, olsRegression as _olsRegression, alignTimeSeries as _alignTimeSeries, };
+//# sourceMappingURL=temporal-causality.js.map

package/dist/learning/pattern-promotion.d.ts

@@ -11,6 +11,8 @@ import type { PatternStore, PatternSearchResult } from './pattern-store.js';
 import type { SQLitePatternStore } from './sqlite-persistence.js';
 import type { RvfDualWriter } from '../integrations/ruvector/rvf-dual-writer.js';
 import type { Result } from '../shared/types/index.js';
+import { type PatternGraph } from '../integrations/ruvector/solver-adapter.js';
+import type { Database as DatabaseType } from 'better-sqlite3';
 /**
  * Dependencies needed for promotion checks
  */
@@ -60,4 +62,65 @@ export declare function seedCrossDomainPatterns(deps: SeedingDeps): Promise<{
     transferred: number;
     skipped: number;
 }>;
+/** SQLite schema for pattern citation graph edges */
+export declare const PATTERN_CITATIONS_SCHEMA = "\n  CREATE TABLE IF NOT EXISTS pattern_citations (\n    source_pattern_id TEXT NOT NULL,\n    target_pattern_id TEXT NOT NULL,\n    weight REAL NOT NULL DEFAULT 1.0,\n    relationship TEXT NOT NULL DEFAULT 'co-occurrence',\n    created_at TEXT DEFAULT (datetime('now')),\n    PRIMARY KEY (source_pattern_id, target_pattern_id)\n  );\n  CREATE INDEX IF NOT EXISTS idx_citations_source ON pattern_citations(source_pattern_id);\n  CREATE INDEX IF NOT EXISTS idx_citations_target ON pattern_citations(target_pattern_id);\n";
+/**
+ * Manages the pattern citation graph in SQLite. Handles schema initialization,
+ * recording co-occurrence edges, and building PatternGraph for PageRank.
+ */
+export declare class PatternCitationGraph {
+    private readonly db;
+    private initialized;
+    constructor(db: DatabaseType);
+    /** Ensure the pattern_citations table exists */
+    ensureSchema(): void;
+    /**
+     * Record that two patterns co-occurred in the same assessment/session.
+     * Increments weight if the edge already exists (stronger co-occurrence).
+     */
+    recordCoOccurrence(patternIdA: string, patternIdB: string): void;
+    /**
+     * Record that pattern B was derived from or supersedes pattern A.
+     */
+    recordDerivation(sourcePatternId: string, derivedPatternId: string): void;
+    /**
+     * Build a PatternGraph from all citation edges in the database.
+     * Returns the graph ready for PageRank computation.
+     */
+    buildGraph(): PatternGraph;
+    /**
+     * Bootstrap the citation graph from existing pattern data.
+     *
+     * Sources:
+     * 1. Same-domain co-occurrence: patterns in the same qe_domain are linked
+     *    (weight = 1.0 per shared domain, reflecting that they co-occur in
+     *    assessments for that domain).
+     * 2. Existing pattern_relationships: "merged" relationships become derivation
+     *    edges (weight = 2.0).
+     *
+     * This is idempotent — uses INSERT OR IGNORE so repeated calls don't
+     * create duplicate edges (but also don't increment weights).
+     *
+     * @returns Number of edges created
+     */
+    bootstrapFromExistingData(): number;
+    /** Get the number of citation edges */
+    getEdgeCount(): number;
+}
+/**
+ * Compute blended importance scores using PageRank over the citation graph
+ * combined with the existing weighted quality formula.
+ *
+ * Blending: final = (1 - alpha) * qualityScore + alpha * pageRankScore
+ *
+ * @param patterns - Patterns to score
+ * @param citationGraph - The pattern citation graph (from PatternCitationGraph.buildGraph())
+ * @param alpha - Blend weight for PageRank (0 = ignore, 1 = only PageRank)
+ */
+export declare function computeBlendedImportance(patterns: Array<{
+    id: string;
+    confidence: number;
+    usageCount: number;
+    successRate: number;
+}>, citationGraph: PatternGraph, alpha?: number): Map<string, number>;
 //# sourceMappingURL=pattern-promotion.d.ts.map

package/dist/learning/pattern-promotion.js

@@ -7,9 +7,11 @@
  */
 import { LoggerFactory } from '../logging/index.js';
 import { toErrorMessage } from '../shared/error-utils.js';
-import { shouldPromotePattern } from './qe-patterns.js';
+import { shouldPromotePattern, calculateQualityScore } from './qe-patterns.js';
 import { getWitnessChain } from '../audit/witness-chain.js';
 import { RELATED_DOMAINS } from './agent-routing.js';
+import { getRuVectorFeatureFlags } from '../integrations/ruvector/feature-flags.js';
+import { PageRankSolver } from '../integrations/ruvector/solver-adapter.js';
 const logger = LoggerFactory.create('PatternPromotion');
 /**
  * Check if a pattern should be promoted with coherence gate (ADR-052)
@@ -81,6 +83,34 @@ export async function promotePattern(patternId, deps) {
                 error: toErrorMessage(e),
             });
         }
+        // Record citation co-occurrence: promoted pattern cites existing long-term patterns
+        // in the same domain (R8, ADR-087)
+        if (getRuVectorFeatureFlags().useSublinearSolver) {
+            try {
+                const db = deps.getSqliteStore().getDatabase?.();
+                if (db) {
+                    const citationGraph = new PatternCitationGraph(db);
+                    const promoted = await deps.getPattern(patternId);
+                    if (promoted) {
+                        const peers = await deps.searchPatterns('', {
+                            domain: promoted.qeDomain, tier: 'long-term', limit: 20,
+                        });
+                        if (peers.success) {
+                            for (const { pattern: peer } of peers.value) {
+                                if (peer.id !== patternId) {
+                                    citationGraph.recordCoOccurrence(patternId, peer.id);
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            catch (e) {
+                logger.warn('Citation graph update failed (non-fatal)', {
+                    error: toErrorMessage(e),
+                });
+            }
+        }
         if (deps.rvfDualWriter) {
             try {
                 const promoted = await deps.getPattern(patternId);
@@ -184,4 +214,208 @@ export async function seedCrossDomainPatterns(deps) {
     logger.info('Cross-domain transfer complete', { transferred, skipped });
     return { transferred, skipped };
 }
+// ============================================================================
+// Pattern Citation Graph & PageRank Scoring (R8, ADR-087)
+// ============================================================================
+/** SQLite schema for pattern citation graph edges */
+export const PATTERN_CITATIONS_SCHEMA = `
+  CREATE TABLE IF NOT EXISTS pattern_citations (
+    source_pattern_id TEXT NOT NULL,
+    target_pattern_id TEXT NOT NULL,
+    weight REAL NOT NULL DEFAULT 1.0,
+    relationship TEXT NOT NULL DEFAULT 'co-occurrence',
+    created_at TEXT DEFAULT (datetime('now')),
+    PRIMARY KEY (source_pattern_id, target_pattern_id)
+  );
+  CREATE INDEX IF NOT EXISTS idx_citations_source ON pattern_citations(source_pattern_id);
+  CREATE INDEX IF NOT EXISTS idx_citations_target ON pattern_citations(target_pattern_id);
+`;
+/**
+ * Manages the pattern citation graph in SQLite. Handles schema initialization,
+ * recording co-occurrence edges, and building PatternGraph for PageRank.
+ */
+export class PatternCitationGraph {
+    db;
+    initialized = false;
+    constructor(db) {
+        this.db = db;
+    }
+    /** Ensure the pattern_citations table exists */
+    ensureSchema() {
+        if (this.initialized)
+            return;
+        this.db.exec(PATTERN_CITATIONS_SCHEMA);
+        this.initialized = true;
+    }
+    /**
+     * Record that two patterns co-occurred in the same assessment/session.
+     * Increments weight if the edge already exists (stronger co-occurrence).
+     */
+    recordCoOccurrence(patternIdA, patternIdB) {
+        this.ensureSchema();
+        // Canonical ordering so (A,B) and (B,A) map to the same edge
+        const [src, tgt] = patternIdA < patternIdB
+            ? [patternIdA, patternIdB]
+            : [patternIdB, patternIdA];
+        this.db.prepare(`
+      INSERT INTO pattern_citations (source_pattern_id, target_pattern_id, weight, relationship)
+      VALUES (?, ?, 1.0, 'co-occurrence')
+      ON CONFLICT(source_pattern_id, target_pattern_id)
+      DO UPDATE SET weight = weight + 1.0
+    `).run(src, tgt);
+    }
+    /**
+     * Record that pattern B was derived from or supersedes pattern A.
+     */
+    recordDerivation(sourcePatternId, derivedPatternId) {
+        this.ensureSchema();
+        this.db.prepare(`
+      INSERT INTO pattern_citations (source_pattern_id, target_pattern_id, weight, relationship)
+      VALUES (?, ?, 2.0, 'derivation')
+      ON CONFLICT(source_pattern_id, target_pattern_id)
+      DO UPDATE SET weight = MAX(weight, 2.0), relationship = 'derivation'
+    `).run(sourcePatternId, derivedPatternId);
+    }
+    /**
+     * Build a PatternGraph from all citation edges in the database.
+     * Returns the graph ready for PageRank computation.
+     */
+    buildGraph() {
+        this.ensureSchema();
+        const rows = this.db.prepare(`SELECT source_pattern_id, target_pattern_id, weight, relationship FROM pattern_citations`).all();
+        // Collect unique node IDs
+        const nodeSet = new Set();
+        for (const row of rows) {
+            nodeSet.add(row.source_pattern_id);
+            nodeSet.add(row.target_pattern_id);
+        }
+        const nodes = Array.from(nodeSet);
+        const nodeIndex = new Map();
+        nodes.forEach((id, i) => nodeIndex.set(id, i));
+        // Build directed edges (both directions for undirected co-occurrence)
+        const edges = [];
+        for (const row of rows) {
+            const si = nodeIndex.get(row.source_pattern_id);
+            const ti = nodeIndex.get(row.target_pattern_id);
+            edges.push([si, ti, row.weight]);
+            if (row.relationship === 'co-occurrence') {
+                edges.push([ti, si, row.weight]); // bidirectional for co-occurrence
+            }
+        }
+        return { nodes, edges };
+    }
+    /**
+     * Bootstrap the citation graph from existing pattern data.
+     *
+     * Sources:
+     * 1. Same-domain co-occurrence: patterns in the same qe_domain are linked
+     *    (weight = 1.0 per shared domain, reflecting that they co-occur in
+     *    assessments for that domain).
+     * 2. Existing pattern_relationships: "merged" relationships become derivation
+     *    edges (weight = 2.0).
+     *
+     * This is idempotent — uses INSERT OR IGNORE so repeated calls don't
+     * create duplicate edges (but also don't increment weights).
+     *
+     * @returns Number of edges created
+     */
+    bootstrapFromExistingData() {
+        this.ensureSchema();
+        let edgesCreated = 0;
+        // 1. Same-domain co-occurrence from qe_patterns
+        // Group patterns by domain, then create pairwise edges within each domain
+        const domainGroups = this.db.prepare(`
+      SELECT id, qe_domain FROM qe_patterns WHERE qe_domain IS NOT NULL ORDER BY qe_domain
+    `).all();
+        const byDomain = new Map();
+        for (const row of domainGroups) {
+            const group = byDomain.get(row.qe_domain) ?? [];
+            group.push(row.id);
+            byDomain.set(row.qe_domain, group);
+        }
+        const insertCoOccurrence = this.db.prepare(`
+      INSERT OR IGNORE INTO pattern_citations (source_pattern_id, target_pattern_id, weight, relationship)
+      VALUES (?, ?, 1.0, 'co-occurrence')
+    `);
+        const insertBatch = this.db.transaction((pairs) => {
+            for (const [a, b] of pairs) {
+                const result = insertCoOccurrence.run(a, b);
+                if (result.changes > 0)
+                    edgesCreated++;
+            }
+        });
+        const pairs = [];
+        for (const [, ids] of byDomain) {
+            // Create pairwise edges (canonical ordering, cap at 50 patterns per domain
+            // to avoid O(n^2) blowup for large domains)
+            const capped = ids.slice(0, 50);
+            for (let i = 0; i < capped.length; i++) {
+                for (let j = i + 1; j < capped.length; j++) {
+                    const [src, tgt] = capped[i] < capped[j]
+                        ? [capped[i], capped[j]]
+                        : [capped[j], capped[i]];
+                    pairs.push([src, tgt]);
+                }
+            }
+        }
+        insertBatch(pairs);
+        // 2. Existing pattern_relationships → derivation edges
+        const relationships = this.db.prepare(`
+      SELECT source_pattern_id, target_pattern_id, relationship_type
+      FROM pattern_relationships
+      WHERE relationship_type IN ('merged', 'derived', 'superseded')
+    `).all();
+        const insertDerivation = this.db.prepare(`
+      INSERT OR IGNORE INTO pattern_citations (source_pattern_id, target_pattern_id, weight, relationship)
+      VALUES (?, ?, 2.0, 'derivation')
+    `);
+        for (const rel of relationships) {
+            const result = insertDerivation.run(rel.source_pattern_id, rel.target_pattern_id);
+            if (result.changes > 0)
+                edgesCreated++;
+        }
+        return edgesCreated;
+    }
+    /** Get the number of citation edges */
+    getEdgeCount() {
+        this.ensureSchema();
+        const row = this.db.prepare('SELECT COUNT(*) as cnt FROM pattern_citations').get();
+        return row.cnt;
+    }
+}
+/**
+ * Compute blended importance scores using PageRank over the citation graph
+ * combined with the existing weighted quality formula.
+ *
+ * Blending: final = (1 - alpha) * qualityScore + alpha * pageRankScore
+ *
+ * @param patterns - Patterns to score
+ * @param citationGraph - The pattern citation graph (from PatternCitationGraph.buildGraph())
+ * @param alpha - Blend weight for PageRank (0 = ignore, 1 = only PageRank)
+ */
+export function computeBlendedImportance(patterns, citationGraph, alpha = 0.3) {
+    const result = new Map();
+    if (!getRuVectorFeatureFlags().useSublinearSolver) {
+        for (const p of patterns) {
+            result.set(p.id, calculateQualityScore(p));
+        }
+        return result;
+    }
+    const qualityScores = new Map();
+    for (const p of patterns) {
+        qualityScores.set(p.id, calculateQualityScore(p));
+    }
+    if (citationGraph.nodes.length < 3 || citationGraph.edges.length < 2) {
+        return qualityScores;
+    }
+    const solver = new PageRankSolver();
+    const pageRankScores = solver.computeImportance(citationGraph);
+    for (const p of patterns) {
+        const quality = qualityScores.get(p.id) ?? 0;
+        const pageRank = pageRankScores.get(p.id) ?? 0;
+        const normalizedPR = pageRank * citationGraph.nodes.length;
+        result.set(p.id, (1 - alpha) * quality + alpha * Math.min(normalizedPR, 1));
+    }
+    return result;
+}
 //# sourceMappingURL=pattern-promotion.js.map

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

@@ -199,6 +199,8 @@ export declare class PatternStore implements IPatternStore {
     private hnswIndex;
     private hnswAvailable;
     private hnswInitPromise;
+    private hdcCache;
+    private deltaTracker;
     private stats;
     constructor(memory: MemoryBackend, config?: Partial<PatternStoreConfig>);
     /**