@jungjaehoon/mama-core 1.4.2 → 1.6.0

package/dist/search/ranker-trainer.js

@@ -0,0 +1,860 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.featureSetVersion = exports.SEARCH_RANKER_FEATURE_SET_VERSION = exports.RANKER_QUALITY_FIXTURES = void 0;
+exports.trainOfflineRanker = trainOfflineRanker;
+exports.scoreWithRankerModel = scoreWithRankerModel;
+exports.evaluateAgainstBaselines = evaluateAgainstBaselines;
+exports.insertRankerModelVersion = insertRankerModelVersion;
+exports.activateRankerModel = activateRankerModel;
+exports.ndcgAtK = ndcgAtK;
+exports.mrr = mrr;
+exports.seedQualityFixtureFeedback = seedQualityFixtureFeedback;
+const node_crypto_1 = require("node:crypto");
+const feedback_store_js_1 = require("./feedback-store.js");
+const ranker_features_js_1 = require("./ranker-features.js");
+Object.defineProperty(exports, "featureSetVersion", { enumerable: true, get: function () { return ranker_features_js_1.featureSetVersion; } });
+Object.defineProperty(exports, "SEARCH_RANKER_FEATURE_SET_VERSION", { enumerable: true, get: function () { return ranker_features_js_1.SEARCH_RANKER_FEATURE_SET_VERSION; } });
+const question_type_js_1 = require("./question-type.js");
+const MS_PER_DAY = 24 * 60 * 60 * 1000;
+const LEARNING_RATE = 0.05;
+const MINI_BATCH_SIZE = 32;
+const MAX_EPOCHS = 500;
+const EARLY_STOP_DELTA = 1e-5;
+const MIN_NEUTRAL_PER_QUERY = 3;
+// 0.01 is a small but meaningful margin across 8 fixture queries: it blocks
+// tie/noise wins without demanding a large jump on a tiny evaluation set.
+const RANKER_QUALITY_MARGIN = 0.01;
+function seededShuffle(items, seed) {
+    const shuffled = [...items];
+    let state = seed >>> 0;
+    for (let index = shuffled.length - 1; index > 0; index -= 1) {
+        state = (state * 1664525 + 1013904223) >>> 0;
+        const swapIndex = state % (index + 1);
+        const current = shuffled[index];
+        shuffled[index] = shuffled[swapIndex];
+        shuffled[swapIndex] = current;
+    }
+    return shuffled;
+}
+function reorderFixtureCandidates(query, candidates) {
+    if (candidates.length <= 1) {
+        return [...candidates];
+    }
+    const seed = Array.from(query).reduce((total, char) => total + char.charCodeAt(0), 0);
+    return seededShuffle(candidates, seed);
+}
+const RAW_RANKER_QUALITY_FIXTURES = [
+    {
+        query: 'fix the stale case status correction',
+        question_type: 'correction',
+        candidates: [
+            {
+                id: 'correction-good-1',
+                source_type: 'decision',
+                bm25_score: 0.18,
+                vector_score: 0.25,
+                case_rollup_score: 0.3,
+                recency_score: 0.4,
+                relevance: 3,
+            },
+            {
+                id: 'correction-bad-1',
+                source_type: 'wiki_page',
+                bm25_score: 0.95,
+                vector_score: 0.86,
+                case_rollup_score: 0.2,
+                recency_score: 0.2,
+                relevance: 0,
+            },
+            {
+                id: 'correction-mid-1',
+                source_type: 'case',
+                bm25_score: 0.45,
+                vector_score: 0.42,
+                case_rollup_score: 0.35,
+                recency_score: 0.1,
+                relevance: 1,
+            },
+            {
+                id: 'correction-bad-2',
+                source_type: 'connector_event',
+                bm25_score: 0.74,
+                vector_score: 0.71,
+                case_rollup_score: 0.25,
+                recency_score: 0.3,
+                relevance: 0,
+            },
+            {
+                id: 'correction-bad-3',
+                source_type: 'checkpoint',
+                bm25_score: 0.61,
+                vector_score: 0.67,
+                case_rollup_score: 0.15,
+                recency_score: 0.2,
+                relevance: 0,
+            },
+        ],
+    },
+    {
+        query: 'revert the mistaken merge decision',
+        question_type: 'correction',
+        candidates: [
+            {
+                id: 'correction-good-2',
+                source_type: 'decision',
+                bm25_score: 0.22,
+                vector_score: 0.2,
+                case_rollup_score: 0.33,
+                recency_score: 0.2,
+                relevance: 3,
+            },
+            {
+                id: 'correction-bad-4',
+                source_type: 'connector_event',
+                bm25_score: 0.92,
+                vector_score: 0.88,
+                case_rollup_score: 0.2,
+                recency_score: 0.3,
+                relevance: 0,
+            },
+            {
+                id: 'correction-mid-2',
+                source_type: 'case',
+                bm25_score: 0.5,
+                vector_score: 0.49,
+                case_rollup_score: 0.38,
+                recency_score: 0.1,
+                relevance: 1,
+            },
+            {
+                id: 'correction-bad-5',
+                source_type: 'wiki_page',
+                bm25_score: 0.7,
+                vector_score: 0.76,
+                case_rollup_score: 0.2,
+                recency_score: 0.2,
+                relevance: 0,
+            },
+            {
+                id: 'correction-bad-6',
+                source_type: 'checkpoint',
+                bm25_score: 0.6,
+                vector_score: 0.57,
+                case_rollup_score: 0.19,
+                recency_score: 0.2,
+                relevance: 0,
+            },
+        ],
+    },
+    {
+        query: 'find the Obsidian doc for the case',
+        question_type: 'artifact',
+        candidates: [
+            {
+                id: 'artifact-good-1',
+                source_type: 'wiki_page',
+                bm25_score: 0.21,
+                vector_score: 0.28,
+                case_rollup_score: 0.3,
+                recency_score: 0.2,
+                relevance: 3,
+            },
+            {
+                id: 'artifact-bad-1',
+                source_type: 'decision',
+                bm25_score: 0.96,
+                vector_score: 0.87,
+                case_rollup_score: 0.21,
+                recency_score: 0.4,
+                relevance: 0,
+            },
+            {
+                id: 'artifact-mid-1',
+                source_type: 'case',
+                bm25_score: 0.44,
+                vector_score: 0.47,
+                case_rollup_score: 0.36,
+                recency_score: 0.2,
+                relevance: 1,
+            },
+            {
+                id: 'artifact-bad-2',
+                source_type: 'connector_event',
+                bm25_score: 0.73,
+                vector_score: 0.74,
+                case_rollup_score: 0.18,
+                recency_score: 0.3,
+                relevance: 0,
+            },
+            {
+                id: 'artifact-bad-3',
+                source_type: 'checkpoint',
+                bm25_score: 0.68,
+                vector_score: 0.62,
+                case_rollup_score: 0.19,
+                recency_score: 0.2,
+                relevance: 0,
+            },
+        ],
+    },
+    {
+        query: 'which pdf described the rollout',
+        question_type: 'artifact',
+        candidates: [
+            {
+                id: 'artifact-good-2',
+                source_type: 'wiki_page',
+                bm25_score: 0.19,
+                vector_score: 0.26,
+                case_rollup_score: 0.31,
+                recency_score: 0.2,
+                relevance: 3,
+            },
+            {
+                id: 'artifact-bad-4',
+                source_type: 'decision',
+                bm25_score: 0.91,
+                vector_score: 0.89,
+                case_rollup_score: 0.21,
+                recency_score: 0.3,
+                relevance: 0,
+            },
+            {
+                id: 'artifact-mid-2',
+                source_type: 'case',
+                bm25_score: 0.49,
+                vector_score: 0.43,
+                case_rollup_score: 0.35,
+                recency_score: 0.3,
+                relevance: 1,
+            },
+            {
+                id: 'artifact-bad-5',
+                source_type: 'connector_event',
+                bm25_score: 0.76,
+                vector_score: 0.72,
+                case_rollup_score: 0.2,
+                recency_score: 0.2,
+                relevance: 0,
+            },
+            {
+                id: 'artifact-bad-6',
+                source_type: 'checkpoint',
+                bm25_score: 0.63,
+                vector_score: 0.61,
+                case_rollup_score: 0.19,
+                recency_score: 0.2,
+                relevance: 0,
+            },
+        ],
+    },
+    {
+        query: 'when did the blocker first happen',
+        question_type: 'timeline',
+        candidates: [
+            {
+                id: 'timeline-good-1',
+                source_type: 'connector_event',
+                bm25_score: 0.2,
+                vector_score: 0.29,
+                case_rollup_score: 0.3,
+                recency_score: 0.2,
+                relevance: 3,
+            },
+            {
+                id: 'timeline-bad-1',
+                source_type: 'decision',
+                bm25_score: 0.93,
+                vector_score: 0.91,
+                case_rollup_score: 0.18,
+                recency_score: 0.3,
+                relevance: 0,
+            },
+            {
+                id: 'timeline-mid-1',
+                source_type: 'checkpoint',
+                bm25_score: 0.48,
+                vector_score: 0.46,
+                case_rollup_score: 0.34,
+                recency_score: 0.2,
+                relevance: 1,
+            },
+            {
+                id: 'timeline-bad-2',
+                source_type: 'case',
+                bm25_score: 0.78,
+                vector_score: 0.74,
+                case_rollup_score: 0.18,
+                recency_score: 0.2,
+                relevance: 0,
+            },
+            {
+                id: 'timeline-bad-3',
+                source_type: 'wiki_page',
+                bm25_score: 0.64,
+                vector_score: 0.63,
+                case_rollup_score: 0.19,
+                recency_score: 0.2,
+                relevance: 0,
+            },
+        ],
+    },
+    {
+        query: 'history before the regression',
+        question_type: 'timeline',
+        candidates: [
+            {
+                id: 'timeline-good-2',
+                source_type: 'connector_event',
+                bm25_score: 0.23,
+                vector_score: 0.27,
+                case_rollup_score: 0.31,
+                recency_score: 0.2,
+                relevance: 3,
+            },
+            {
+                id: 'timeline-bad-4',
+                source_type: 'decision',
+                bm25_score: 0.94,
+                vector_score: 0.9,
+                case_rollup_score: 0.18,
+                recency_score: 0.3,
+                relevance: 0,
+            },
+            {
+                id: 'timeline-mid-2',
+                source_type: 'checkpoint',
+                bm25_score: 0.47,
+                vector_score: 0.45,
+                case_rollup_score: 0.36,
+                recency_score: 0.2,
+                relevance: 1,
+            },
+            {
+                id: 'timeline-bad-5',
+                source_type: 'case',
+                bm25_score: 0.75,
+                vector_score: 0.77,
+                case_rollup_score: 0.19,
+                recency_score: 0.2,
+                relevance: 0,
+            },
+            {
+                id: 'timeline-bad-6',
+                source_type: 'wiki_page',
+                bm25_score: 0.62,
+                vector_score: 0.64,
+                case_rollup_score: 0.18,
+                recency_score: 0.2,
+                relevance: 0,
+            },
+        ],
+    },
+    {
+        query: 'current status of the rollout',
+        question_type: 'status',
+        candidates: [
+            {
+                id: 'status-good-1',
+                source_type: 'case',
+                bm25_score: 0.2,
+                vector_score: 0.24,
+                case_rollup_score: 0.36,
+                recency_score: 0.2,
+                relevance: 3,
+            },
+            {
+                id: 'status-bad-1',
+                source_type: 'decision',
+                bm25_score: 0.97,
+                vector_score: 0.9,
+                case_rollup_score: 0.2,
+                recency_score: 0.3,
+                relevance: 0,
+            },
+            {
+                id: 'status-mid-1',
+                source_type: 'checkpoint',
+                bm25_score: 0.46,
+                vector_score: 0.47,
+                case_rollup_score: 0.34,
+                recency_score: 0.2,
+                relevance: 1,
+            },
+            {
+                id: 'status-bad-2',
+                source_type: 'connector_event',
+                bm25_score: 0.74,
+                vector_score: 0.73,
+                case_rollup_score: 0.19,
+                recency_score: 0.2,
+                relevance: 0,
+            },
+            {
+                id: 'status-bad-3',
+                source_type: 'wiki_page',
+                bm25_score: 0.65,
+                vector_score: 0.62,
+                case_rollup_score: 0.18,
+                recency_score: 0.2,
+                relevance: 0,
+            },
+        ],
+    },
+    {
+        query: 'latest progress on case assembly',
+        question_type: 'status',
+        candidates: [
+            {
+                id: 'status-good-2',
+                source_type: 'case',
+                bm25_score: 0.22,
+                vector_score: 0.23,
+                case_rollup_score: 0.37,
+                recency_score: 0.2,
+                relevance: 3,
+            },
+            {
+                id: 'status-bad-4',
+                source_type: 'decision',
+                bm25_score: 0.92,
+                vector_score: 0.91,
+                case_rollup_score: 0.2,
+                recency_score: 0.3,
+                relevance: 0,
+            },
+            {
+                id: 'status-mid-2',
+                source_type: 'checkpoint',
+                bm25_score: 0.48,
+                vector_score: 0.45,
+                case_rollup_score: 0.34,
+                recency_score: 0.2,
+                relevance: 1,
+            },
+            {
+                id: 'status-bad-5',
+                source_type: 'connector_event',
+                bm25_score: 0.77,
+                vector_score: 0.75,
+                case_rollup_score: 0.2,
+                recency_score: 0.2,
+                relevance: 0,
+            },
+            {
+                id: 'status-bad-6',
+                source_type: 'wiki_page',
+                bm25_score: 0.66,
+                vector_score: 0.63,
+                case_rollup_score: 0.18,
+                recency_score: 0.2,
+                relevance: 0,
+            },
+        ],
+    },
+];
+exports.RANKER_QUALITY_FIXTURES = RAW_RANKER_QUALITY_FIXTURES.map((fixture) => ({
+    ...fixture,
+    candidates: reorderFixtureCandidates(fixture.query, fixture.candidates),
+}));
+function asSourceForFeedback(sourceType) {
+    switch (sourceType) {
+        case 'wiki_page':
+            return 'wiki_page';
+        case 'case':
+            return 'case';
+        case 'connector_event':
+            return 'connector_event';
+        case 'checkpoint':
+            return 'checkpoint';
+        default:
+            return 'decision';
+    }
+}
+function parseDate(input, field) {
+    const date = new Date(input);
+    if (Number.isNaN(date.getTime())) {
+        throw new Error(`${field} must be a valid ISO timestamp`);
+    }
+    return date;
+}
+function iso(date) {
+    return date.toISOString();
+}
+function effectiveWindow(input) {
+    const retentionDays = (0, feedback_store_js_1.getFeedbackRetentionDays)(input.adapter);
+    const now = input.now ?? new Date();
+    const retentionCutoff = new Date(now.getTime() - retentionDays * MS_PER_DAY);
+    const until = input.until ? parseDate(input.until, 'until') : now;
+    const since = input.since ? parseDate(input.since, 'since') : retentionCutoff;
+    if (since.getTime() > until.getTime()) {
+        throw new Error('since must be before until');
+    }
+    const retentionWarning = Boolean(input.since && since.getTime() < retentionCutoff.getTime());
+    if (retentionWarning) {
+        console.warn(JSON.stringify({
+            event: 'training_window_exceeds_retention',
+            since: iso(since),
+            retention_cutoff_at: iso(retentionCutoff),
+        }));
+    }
+    return {
+        since: iso(since),
+        until: iso(until),
+        retention_cutoff_at: iso(retentionCutoff),
+        retention_days_at_train_time: retentionDays,
+        retention_warning: retentionWarning,
+    };
+}
+function labelForKind(kind) {
+    if (kind === 'accept' || kind === 'click') {
+        return 1;
+    }
+    if (kind === 'reject' || kind === 'hide' || kind === 'shown') {
+        return 0;
+    }
+    return null;
+}
+function rowToExample(row) {
+    const label = labelForKind(row.feedback_kind);
+    if (label === null) {
+        return null;
+    }
+    const features = (0, ranker_features_js_1.serializeFeatures)((0, ranker_features_js_1.extractFeatures)({
+        ...row,
+        source_type: row.result_source_type,
+        rank_position: row.rank_position,
+    }, row.query, { question_type: row.question_type }));
+    return {
+        query: row.query,
+        question_type: row.question_type,
+        features,
+        label,
+        feedback_kind: row.feedback_kind,
+        created_at: row.created_at,
+        feedback_id: row.feedback_id,
+    };
+}
+function capNeutralRows(rows) {
+    const byQuery = new Map();
+    for (const row of rows) {
+        const key = row.query_hash_hex || row.query;
+        const current = byQuery.get(key) ?? [];
+        current.push(row);
+        byQuery.set(key, current);
+    }
+    const capped = [];
+    for (const groupRows of byQuery.values()) {
+        const explicit = groupRows.filter((row) => row.feedback_kind !== 'shown');
+        const shown = groupRows.filter((row) => row.feedback_kind === 'shown');
+        const neutralLimit = Math.max(explicit.length * 3, MIN_NEUTRAL_PER_QUERY);
+        capped.push(...explicit, ...shown.slice(0, neutralLimit));
+    }
+    capped.sort((left, right) => {
+        const byCreatedAt = left.created_at.localeCompare(right.created_at);
+        return byCreatedAt !== 0 ? byCreatedAt : left.feedback_id.localeCompare(right.feedback_id);
+    });
+    return capped;
+}
+function sigmoid(value) {
+    if (value >= 35) {
+        return 1;
+    }
+    if (value <= -35) {
+        return 0;
+    }
+    return 1 / (1 + Math.exp(-value));
+}
+function dot(left, right) {
+    const length = Math.min(left.length, right.length);
+    let total = 0;
+    for (let index = 0; index < length; index += 1) {
+        total += left[index] * right[index];
+    }
+    return total;
+}
+function hasBothLabels(examples) {
+    const labels = new Set(examples.map((example) => example.label));
+    return labels.has(0) && labels.has(1);
+}
+function trainWeights(examples, featureCount) {
+    const coefficients = new Array(featureCount).fill(0);
+    let intercept = 0;
+    if (examples.length === 0 || !hasBothLabels(examples)) {
+        return { coefficients, intercept };
+    }
+    for (let epoch = 0; epoch < MAX_EPOCHS; epoch += 1) {
+        const shuffledExamples = seededShuffle(examples, epoch + 1);
+        let epochDelta = 0;
+        let batchCount = 0;
+        for (let batchStart = 0; batchStart < shuffledExamples.length; batchStart += MINI_BATCH_SIZE) {
+            const batch = shuffledExamples.slice(batchStart, batchStart + MINI_BATCH_SIZE);
+            const gradients = new Array(featureCount).fill(0);
+            let interceptGradient = 0;
+            for (const example of batch) {
+                const prediction = sigmoid(dot(coefficients, example.features) + intercept);
+                const error = prediction - example.label;
+                for (let index = 0; index < featureCount; index += 1) {
+                    gradients[index] += error * example.features[index];
+                }
+                interceptGradient += error;
+            }
+            let delta = 0;
+            for (let index = 0; index < featureCount; index += 1) {
+                const update = (LEARNING_RATE * gradients[index]) / batch.length;
+                coefficients[index] -= update;
+                delta += Math.abs(update);
+            }
+            const interceptUpdate = (LEARNING_RATE * interceptGradient) / batch.length;
+            intercept -= interceptUpdate;
+            delta += Math.abs(interceptUpdate);
+            epochDelta += delta;
+            batchCount += 1;
+        }
+        if (batchCount > 0 && epochDelta / batchCount < EARLY_STOP_DELTA) {
+            break;
+        }
+    }
+    return { coefficients, intercept };
+}
+function questionWeights(examples, featureCount, fallback) {
+    const output = {};
+    for (const questionType of question_type_js_1.QUESTION_TYPES) {
+        const subset = examples.filter((example) => example.question_type === questionType);
+        output[questionType] = hasBothLabels(subset)
+            ? trainWeights(subset, featureCount).coefficients
+            : [...fallback];
+    }
+    return output;
+}
+function modelIdFor(input) {
+    const compactTime = input.trainedAt.replace(/[^0-9]/g, '').slice(0, 17);
+    const uniqueSuffix = (0, node_crypto_1.randomBytes)(4).toString('hex');
+    return `ranker_${compactTime}_${input.rows}_${input.distinctQueries}_${uniqueSuffix}`;
+}
+async function trainOfflineRanker(input) {
+    const minFeedbackRows = input.minFeedbackRows ?? 1000;
+    const minDistinctQueries = input.minDistinctQueries ?? 10;
+    const window = effectiveWindow(input);
+    const rows = (0, feedback_store_js_1.listSearchFeedback)(input.adapter, {
+        since: window.since,
+        until: window.until,
+    });
+    const cappedRows = capNeutralRows(rows);
+    const examples = cappedRows
+        .map(rowToExample)
+        .filter((example) => Boolean(example));
+    const distinctQueries = new Set(examples.map((example) => example.query.trim().toLowerCase()))
+        .size;
+    const counts = {
+        feedbackRows: examples.length,
+        distinctQueries,
+    };
+    const examplesHaveBothLabels = hasBothLabels(examples);
+    if (counts.feedbackRows < minFeedbackRows ||
+        counts.distinctQueries < minDistinctQueries ||
+        !examplesHaveBothLabels) {
+        return {
+            status: 'insufficient_data',
+            effectiveWindow: window,
+            counts,
+        };
+    }
+    const featureCount = examples[0].features.length;
+    const trained = trainWeights(examples, featureCount);
+    const trainedAt = input.now ? input.now.toISOString() : new Date().toISOString();
+    const model = {
+        model_id: modelIdFor({
+            trainedAt,
+            rows: counts.feedbackRows,
+            distinctQueries: counts.distinctQueries,
+        }),
+        feature_set_version: input.featureSetVersion ?? (0, ranker_features_js_1.featureSetVersion)(),
+        trained_at: trainedAt,
+        training_rows_count: examples.length,
+        coefficients: trained.coefficients,
+        intercept: trained.intercept,
+        question_type_weights: questionWeights(examples, featureCount, trained.coefficients),
+        training_window: window,
+    };
+    return {
+        status: 'trained',
+        model,
+        effectiveWindow: window,
+        counts,
+    };
+}
+function rankByScore(items, score) {
+    return items
+        .map((item) => ({ item, score: score(item) }))
+        .sort((left, right) => {
+        const diff = right.score - left.score;
+        if (Math.abs(diff) > 1e-12) {
+            return diff;
+        }
+        return left.item.id.localeCompare(right.item.id);
+    })
+        .map((entry) => entry.item);
+}
+function reciprocalRankRanks(items, leftScore, rightScore) {
+    const left = rankByScore(items, leftScore);
+    const right = rankByScore(items, rightScore);
+    const leftRanks = new Map(left.map((item, index) => [item.id, index + 1]));
+    const rightRanks = new Map(right.map((item, index) => [item.id, index + 1]));
+    return rankByScore(items, (item) => {
+        const leftRank = leftRanks.get(item.id) ?? items.length;
+        const rightRank = rightRanks.get(item.id) ?? items.length;
+        return 1 / (60 + leftRank) + 1 / (60 + rightRank);
+    });
+}
+function scoreWithRankerModel(model, row, query, questionType) {
+    const features = (0, ranker_features_js_1.serializeFeatures)((0, ranker_features_js_1.extractFeatures)(row, query, { question_type: questionType }));
+    const coefficients = model.question_type_weights[questionType] ?? model.coefficients;
+    return sigmoid(dot(coefficients, features) + model.intercept);
+}
+function baselineMetrics(fixtures, ranker) {
+    const perQuery = {};
+    let ndcgTotal = 0;
+    let mrrTotal = 0;
+    for (const fixture of fixtures) {
+        const ranked = ranker(fixture);
+        const relevance = new Map(fixture.candidates.map((candidate) => [candidate.id, candidate.relevance]));
+        const relevantSet = new Set(fixture.candidates
+            .filter((candidate) => candidate.relevance > 0)
+            .map((candidate) => candidate.id));
+        const ndcg = ndcgAtK(ranked, relevance, 5);
+        const mrrScore = mrr(ranked, relevantSet);
+        perQuery[fixture.query] = { ndcg, mrr: mrrScore };
+        ndcgTotal += ndcg;
+        mrrTotal += mrrScore;
+    }
+    return {
+        ndcg: ndcgTotal / fixtures.length,
+        mrr: mrrTotal / fixtures.length,
+        per_query: perQuery,
+    };
+}
+async function evaluateAgainstBaselines(_input, model) {
+    const bm25 = baselineMetrics(exports.RANKER_QUALITY_FIXTURES, (fixture) => rankByScore(fixture.candidates, (candidate) => candidate.bm25_score));
+    const vector = baselineMetrics(exports.RANKER_QUALITY_FIXTURES, (fixture) => rankByScore(fixture.candidates, (candidate) => candidate.vector_score));
+    const rrf = baselineMetrics(exports.RANKER_QUALITY_FIXTURES, (fixture) => reciprocalRankRanks(fixture.candidates, (candidate) => candidate.bm25_score, (candidate) => candidate.vector_score));
+    const logistic = baselineMetrics(exports.RANKER_QUALITY_FIXTURES, (fixture) => rankByScore(fixture.candidates, (candidate) => 0.5 * candidate.bm25_score + 0.5 * candidate.vector_score));
+    const learned = baselineMetrics(exports.RANKER_QUALITY_FIXTURES, (fixture) => rankByScore(fixture.candidates, (candidate) => scoreWithRankerModel(model, candidate, fixture.query, fixture.question_type)));
+    const bestBaselineNdcg = Math.max(bm25.ndcg, vector.ndcg, rrf.ndcg, logistic.ndcg);
+    const bestBaselineMrr = Math.max(bm25.mrr, vector.mrr, rrf.mrr, logistic.mrr);
+    return {
+        bm25,
+        vector,
+        rrf,
+        logistic,
+        learned,
+        passes: learned.ndcg >= bestBaselineNdcg + RANKER_QUALITY_MARGIN &&
+            learned.mrr >= bestBaselineMrr + RANKER_QUALITY_MARGIN,
+    };
+}
+function runTransaction(adapter, fn) {
+    if (!adapter.transaction) {
+        return fn();
+    }
+    const result = adapter.transaction(fn);
+    if (typeof result === 'function') {
+        return result();
+    }
+    return result;
+}
+async function insertRankerModelVersion(adapter, model, evaluation) {
+    const coefficientsPayload = JSON.stringify({
+        coefficients: model.coefficients,
+        intercept: model.intercept,
+        question_type_weights: model.question_type_weights,
+        training_rows_count: model.training_rows_count,
+    });
+    const metricsPayload = JSON.stringify({
+        learned: evaluation.learned,
+        passes: evaluation.passes,
+    });
+    const baselinePayload = JSON.stringify({
+        bm25: evaluation.bm25,
+        vector: evaluation.vector,
+        rrf: evaluation.rrf,
+        logistic: evaluation.logistic,
+    });
+    const trainingWindowPayload = JSON.stringify(model.training_window ?? {
+        since: null,
+        until: null,
+        retention_cutoff_at: null,
+        retention_days_at_train_time: null,
+        retention_warning: false,
+    });
+    adapter
+        .prepare(`
+        INSERT INTO ranker_model_versions (
+          model_id, model_version, feature_set_version, coefficients_json, metrics_json,
+          training_window_json, baseline_metrics_json, quality_gate_status, trained_at,
+          trained_by, active
+        )
+        VALUES (?, 'offline-logistic-v1', ?, ?, ?, ?, ?, ?, ?, 'mama train-ranker', 0)
+      `)
+        .run(model.model_id, model.feature_set_version, coefficientsPayload, metricsPayload, trainingWindowPayload, baselinePayload, evaluation.passes ? 'passed' : 'failed', model.trained_at);
+    return { model_id: model.model_id, active: false };
+}
+async function activateRankerModel(adapter, model_id) {
+    const row = adapter
+        .prepare(`
+        SELECT model_id, feature_set_version, quality_gate_status
+        FROM ranker_model_versions
+        WHERE model_id = ?
+      `)
+        .get(model_id);
+    if (!row) {
+        return 'not_found';
+    }
+    if (row.feature_set_version !== ranker_features_js_1.SEARCH_RANKER_FEATURE_SET_VERSION) {
+        return 'feature_set_mismatch';
+    }
+    if (row.quality_gate_status !== 'passed') {
+        return 'quality_gate_failed';
+    }
+    runTransaction(adapter, () => {
+        adapter.prepare('UPDATE ranker_model_versions SET active = 0 WHERE active = 1').run();
+        adapter.prepare('UPDATE ranker_model_versions SET active = 1 WHERE model_id = ?').run(model_id);
+    });
+    return 'activated';
+}
+function ndcgAtK(results, relevanceMap, k) {
+    const gains = results.slice(0, k).map((result, index) => {
+        const relevance = relevanceMap.get(result.id) ?? 0;
+        return (2 ** relevance - 1) / Math.log2(index + 2);
+    });
+    const dcg = gains.reduce((sum, gain) => sum + gain, 0);
+    const ideal = Array.from(relevanceMap.values())
+        .sort((left, right) => right - left)
+        .slice(0, k)
+        .map((relevance, index) => (2 ** relevance - 1) / Math.log2(index + 2))
+        .reduce((sum, gain) => sum + gain, 0);
+    return ideal === 0 ? 0 : dcg / ideal;
+}
+function mrr(results, relevantSet) {
+    const index = results.findIndex((result) => relevantSet.has(result.id));
+    return index === -1 ? 0 : 1 / (index + 1);
+}
+function seedQualityFixtureFeedback(adapter, createdAt = '2026-04-18T00:00:00.000Z') {
+    let counter = 0;
+    for (const fixture of exports.RANKER_QUALITY_FIXTURES) {
+        for (const candidate of fixture.candidates) {
+            counter += 1;
+            const kind = candidate.relevance >= 3 ? 'accept' : 'reject';
+            adapter
+                .prepare(`
+            INSERT INTO search_feedback (
+              feedback_id, query, query_hash, question_type, result_source_type, result_source_id,
+              case_id, feedback_kind, rank_position, score_before, score_after, session_id,
+              actor, metadata_json, created_at, updated_at
+            )
+            VALUES (?, ?, zeroblob(32), ?, ?, ?, NULL, ?, ?, NULL, NULL, ?, 'test:ranker-fixture', '{}', ?, NULL)
+          `)
+                .run(`quality-${counter}`, fixture.query, fixture.question_type, asSourceForFeedback(candidate.source_type), candidate.id, kind, counter % 5, `fixture:${fixture.question_type}`, createdAt);
+        }
+    }
+}
+//# sourceMappingURL=ranker-trainer.js.map