truthguard-ai 0.2.0 → 0.3.0

package/dist-npm/L2/index.js

@@ -0,0 +1,1773 @@
+"use strict";
+/**
+ * L2 — Structured Context Matching
+ *
+ * Extracts and matches claims that L1 (regex-based) cannot handle:
+ *   - boolean fields (true/false → natural language equivalents)
+ *   - enum/status fields (approved → "odobren", active → "aktivan")
+ *   - list_items — verifies that response mentions all items from tool output arrays
+ *   - key_value — matches identifiers (email, phone, ID) from tool output against response
+ *   - aggregation — verifies SUM/AVG/COUNT/MIN/MAX computed from tool output arrays
+ *
+ * Fully deterministic — no LLM calls. Domain-specific enum translation
+ * tables enable cross-language matching (EN → SR, etc.).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractStructuredClaims = extractStructuredClaims;
+exports.matchBoolean = matchBoolean;
+exports.matchEnum = matchEnum;
+exports.addEnumTranslations = addEnumTranslations;
+exports.getEnumTranslations = getEnumTranslations;
+exports.extractListItemsClaims = extractListItemsClaims;
+exports.matchListItems = matchListItems;
+exports.extractKeyValueClaims = extractKeyValueClaims;
+exports.matchKeyValue = matchKeyValue;
+exports.extractAggregationClaims = extractAggregationClaims;
+exports.matchAggregation = matchAggregation;
+exports.extractRangeClaims = extractRangeClaims;
+exports.matchRange = matchRange;
+const crypto_1 = require("crypto");
+const Trace_1 = require("../Trace");
+const Matchers_1 = require("../Matchers");
+// ---------------------------------------------------------------------------
+// Boolean synonym tables
+// ---------------------------------------------------------------------------
+/** Maps boolean true/false to natural-language equivalents. */
+const BOOLEAN_SYNONYMS = {
+    true: [
+        // English
+        'true', 'yes', 'active', 'enabled', 'on', 'present', 'available',
+        'approved', 'confirmed', 'valid', 'open', 'done', 'completed',
+        // Serbian (Latin + Cyrillic-transliterated)
+        'da', 'aktivan', 'aktivna', 'aktivno', 'aktivni',
+        'prisutan', 'prisutna', 'prisutno', 'prisutni',
+        'dostupan', 'dostupna', 'dostupno',
+        'odobren', 'odobrena', 'odobreno',
+        'otvoren', 'otvorena', 'otvoreno',
+        'zavrseno', 'završeno', 'završen', 'završena',
+    ],
+    false: [
+        // English
+        'false', 'no', 'inactive', 'disabled', 'off', 'absent', 'unavailable',
+        'rejected', 'denied', 'invalid', 'closed', 'pending', 'not done',
+        // Serbian
+        'ne', 'neaktivan', 'neaktivna', 'neaktivno',
+        'odsutan', 'odsutna', 'odsutno', 'odsutni',
+        'nedostupan', 'nedostupna', 'nedostupno',
+        'odbijen', 'odbijena', 'odbijeno',
+        'zatvoren', 'zatvorena', 'zatvoreno',
+    ],
+};
+// ---------------------------------------------------------------------------
+// Enum translation table
+// ---------------------------------------------------------------------------
+/**
+ * Maps common enum values to their natural-language equivalents.
+ * Each entry: canonical_value → [synonyms in multiple languages]
+ *
+ * Organized by domain. Users can extend via addEnumTranslations().
+ */
+const ENUM_TRANSLATIONS = {
+    // Status values
+    approved: ['approved', 'odobren', 'odobrena', 'odobreno', 'odobreni',
+        'aprobado', 'aprobada', 'approuvé', 'approuvée', 'aprovado', 'aprovada',
+        'одобрен', 'одобрена', 'одобрено', 'स्वीकृत', 'موافق', 'অনুমোদিত', '已批准', '承認済み'],
+    rejected: ['rejected', 'odbijen', 'odbijena', 'odbijeno', 'odbijeni',
+        'rechazado', 'rechazada', 'rejeté', 'rejetée', 'rejeitado', 'rejeitada',
+        'отклонён', 'отклонена', 'अस्वीकृत', 'مرفوض', 'প্রত্যাখ্যাত', '已拒绝', '却下'],
+    pending: ['pending', 'na cekanju', 'na čekanju', 'čeka', 'ceka', 'u toku',
+        'pendiente', 'en attente', 'pendente',
+        'ожидание', 'на рассмотрении', 'लंबित', 'معلق', 'মুলতুবি', '待定', '待处理', '保留中'],
+    active: ['active', 'aktivan', 'aktivna', 'aktivno', 'aktivni',
+        'activo', 'activa', 'actif', 'active', 'ativo', 'ativa',
+        'активный', 'активна', 'сक्रिय', 'نشط', 'সক্রিয়', '活跃', 'アクティブ'],
+    inactive: ['inactive', 'neaktivan', 'neaktivna', 'neaktivno', 'neaktivni',
+        'inactivo', 'inactiva', 'inactif', 'inactive', 'inativo', 'inativa',
+        'неактивный', 'неактивна', 'निष्क्रिय', 'غير نشط', 'নিষ্ক্রিয়', '不活跃', '非アクティブ'],
+    completed: ['completed', 'završen', 'završena', 'završeno', 'zavrseno', 'gotov', 'gotovo',
+        'completado', 'completada', 'terminé', 'terminée', 'concluído', 'concluída',
+        'завершён', 'завершена', 'पूर्ण', 'مكتمل', 'সম্পূর্ণ', '已完成', '完了'],
+    cancelled: ['cancelled', 'canceled', 'otkazan', 'otkazana', 'otkazano', 'otkazani',
+        'cancelado', 'cancelada', 'annulé', 'annulée', 'cancelado', 'cancelada',
+        'отменён', 'отменена', 'रद्द', 'ملغى', 'বাতিল', '已取消', 'キャンセル'],
+    open: ['open', 'otvoren', 'otvorena', 'otvoreno', 'otvoreni',
+        'abierto', 'abierta', 'ouvert', 'ouverte', 'aberto', 'aberta',
+        'открыт', 'открыта', 'खुला', 'مفتوح', 'খোলা', '开放', 'オープン'],
+    closed: ['closed', 'zatvoren', 'zatvorena', 'zatvoreno', 'zatvoreni',
+        'cerrado', 'cerrada', 'fermé', 'fermée', 'fechado', 'fechada',
+        'закрыт', 'закрыта', 'बंद', 'مغلق', 'বন্ধ', '已关闭', 'クローズ'],
+    // Leave / HR
+    on_leave: ['on leave', 'on_leave', 'na odmoru', 'na godišnjem', 'na godisnjem', 'odsutan', 'odsutna',
+        'de permiso', 'en congé', 'de licença',
+        'в отпуске', 'छुट्टी पर', 'في إجازة', 'ছুটিতে', '休假中', '休暇中'],
+    sick_leave: ['sick leave', 'sick_leave', 'bolovanje', 'na bolovanju',
+        'baja por enfermedad', 'congé maladie', 'licença médica',
+        'на больничном', 'बीमार छुट्टी', 'إجازة مرضية', 'অসুস্থতার ছুটি', '病假', '病気休暇'],
+    present: ['present', 'prisutan', 'prisutna', 'prisutno', 'prisutni',
+        'presente', 'présent', 'présente',
+        'присутствует', 'उपस्थित', 'حاضر', 'উপস্থিত', '在场', '出席'],
+    absent: ['absent', 'odsutan', 'odsutna', 'odsutno', 'odsutni',
+        'ausente', 'absent', 'absente',
+        'отсутствует', 'अनुपस्थित', 'غائب', 'অনুপস্থিত', '缺席', '欠席'],
+    late: ['late', 'kasni', 'kasnio', 'kasnila', 'zakašnjenje', 'zakasnjenje',
+        'tarde', 'retardado', 'en retard', 'atrasado', 'atrasada',
+        'опоздание', 'опоздал', 'देर से', 'متأخر', 'দেরি', '迟到', '遅刻'],
+    // Priority
+    high: ['high', 'visok', 'visoka', 'visoko', 'visoki', 'hitno', 'urgent',
+        'alto', 'alta', 'élevé', 'élevée', 'haut', 'haute',
+        'высокий', 'высокая', 'उच्च', 'عالي', 'উচ্চ', '高', '高い'],
+    medium: ['medium', 'srednji', 'srednja', 'srednje',
+        'medio', 'media', 'moyen', 'moyenne', 'médio', 'média',
+        'средний', 'средняя', 'मध्यम', 'متوسط', 'মাঝারি', '中', '中くらい'],
+    low: ['low', 'nizak', 'niska', 'nisko', 'niski',
+        'bajo', 'baja', 'bas', 'basse', 'baixo', 'baixa',
+        'низкий', 'низкая', 'कम', 'منخفض', 'নিম্ন', '低', '低い'],
+    critical: ['critical', 'kritičan', 'kritična', 'kritično', 'kritican',
+        'crítico', 'crítica', 'critique', 'crítico', 'crítica',
+        'критический', 'критическая', 'गंभीर', 'حرج', 'জটিল', '紧急', '重大'],
+    // Boolean-like strings
+    yes: ['yes', 'da',
+        'sí', 'oui', 'sim', 'да', 'हाँ', 'نعم', 'হ্যাঁ', '是', 'はい'],
+    no: ['no', 'ne', 'nije',
+        'no', 'non', 'não', 'нет', 'नहीं', 'لا', 'না', '否', 'いいえ'],
+    // Payment
+    paid: ['paid', 'plaćen', 'plaćena', 'plaćeno', 'placen', 'placeno',
+        'pagado', 'pagada', 'payé', 'payée', 'pago', 'paga',
+        'оплачено', 'भुगतान किया', 'مدفوع', 'পরিশোধিত', '已支付', '支払済み'],
+    unpaid: ['unpaid', 'neplaćen', 'neplaćena', 'neplaćeno', 'neplacen',
+        'impago', 'impagado', 'non payé', 'não pago',
+        'не оплачено', 'अवैतनिक', 'غير مدفوع', 'অপরিশোধিত', '未支付', '未払い'],
+    overdue: ['overdue', 'zakasnelo', 'kasni', 'dospelo', 'dospela',
+        'vencido', 'vencida', 'en retard', 'atrasado', 'atrasada',
+        'просрочено', 'अतिदेय', 'متأخر', 'বকেয়া', '逾期', '期限超過'],
+    // General
+    enabled: ['enabled', 'uključen', 'uključena', 'ukljucen', 'ukljucena',
+        'habilitado', 'habilitada', 'activé', 'activée', 'ativado', 'ativada',
+        'включён', 'включена', 'सक्षम', 'مفعل', 'সক্রিয়', '已启用', '有効'],
+    disabled: ['disabled', 'isključen', 'isključena', 'iskljucen', 'iskljucena',
+        'deshabilitado', 'deshabilitada', 'désactivé', 'désactivée', 'desativado', 'desativada',
+        'отключён', 'отключена', 'अक्षम', 'معطل', 'নিষ্ক্রিয়', '已禁用', '無効'],
+    available: ['available', 'dostupan', 'dostupna', 'dostupno',
+        'disponible', 'disponible', 'disponível',
+        'доступен', 'доступна', 'उपलब्ध', 'متاح', 'উপলব্ধ', '可用', '利用可能'],
+    unavailable: ['unavailable', 'nedostupan', 'nedostupna', 'nedostupno',
+        'no disponible', 'indisponible', 'indisponível',
+        'недоступен', 'недоступна', 'अनुपलब्ध', 'غير متاح', 'অনুপলব্ধ', '不可用', '利用不可'],
+    success: ['success', 'uspešno', 'uspesno', 'uspeh',
+        'éxito', 'succès', 'sucesso',
+        'успех', 'успешно', 'सफलता', 'نجاح', 'সাফল্য', '成功', '成功'],
+    failed: ['failed', 'neuspešno', 'neuspesno', 'neuspeo', 'neuspela', 'greška', 'greska',
+        'fallido', 'fallida', 'échoué', 'falhou',
+        'неудача', 'провал', 'विफल', 'فشل', 'ব্যর্থ', '失败', '失敗'],
+    error: ['error', 'greška', 'greska',
+        'error', 'erreur', 'erro',
+        'ошибка', 'त्रुटि', 'خطأ', 'ত্রুটি', '错误', 'エラー'],
+};
+/**
+ * Semantic opposites: maps each canonical enum value to a set of values
+ * that can meaningfully contradict it. Without this, findContradiction
+ * scans ALL enum values, causing false positives (e.g. "da" matching
+ * for "active" status fields in Serbian text).
+ */
+const ENUM_OPPOSITES = {
+    approved: ['rejected', 'pending', 'cancelled'],
+    rejected: ['approved', 'pending'],
+    pending: ['approved', 'rejected', 'completed', 'cancelled'],
+    active: ['inactive'],
+    inactive: ['active'],
+    completed: ['pending', 'cancelled', 'open'],
+    cancelled: ['pending', 'completed'],
+    open: ['closed', 'completed'],
+    closed: ['open'],
+    present: ['absent', 'on_leave', 'sick_leave', 'late'],
+    absent: ['present'],
+    on_leave: ['present'],
+    sick_leave: ['present'],
+    late: ['present'],
+    yes: ['no'],
+    no: ['yes'],
+    paid: ['unpaid', 'overdue'],
+    unpaid: ['paid'],
+    overdue: ['paid'],
+    enabled: ['disabled'],
+    disabled: ['enabled'],
+    available: ['unavailable'],
+    unavailable: ['available'],
+    success: ['failed', 'error'],
+    failed: ['success'],
+    error: ['success'],
+    high: ['medium', 'low'],
+    medium: ['high', 'low', 'critical'],
+    low: ['high', 'medium', 'critical'],
+    critical: ['low', 'medium'],
+};
+/**
+ * Words that are common function words in supported languages and should
+ * NOT be matched as standalone enum/boolean synonyms in running text.
+ * They are only valid when the response is essentially just that word.
+ */
+const AMBIGUOUS_SHORT_WORDS = new Set([
+    // Latin short words that collide with function words
+    'da', 'ne', 'on', 'an', 'no', 'non', 'sim',
+    // Cyrillic — "да" is a conjunction in Russian, not just "yes"
+    'да',
+    // CJK single characters — extremely common in running text
+    '是', '否', '高', '中', '低',
+    // Japanese kana that double as particles/prefixes
+    'に', 'ご',
+    // Arabic — "لا" is ubiquitous negation particle
+    'لا',
+    // Bengali — "না" is common negation
+    'না',
+]);
+/** Build a reverse-lookup: synonym → canonical value. */
+function buildReverseLookup() {
+    const map = new Map();
+    for (const [canonical, synonyms] of Object.entries(ENUM_TRANSLATIONS)) {
+        for (const syn of synonyms) {
+            map.set(syn.toLowerCase(), canonical);
+        }
+    }
+    return map;
+}
+const ENUM_REVERSE = buildReverseLookup();
+// ---------------------------------------------------------------------------
+// L2 Claim Extraction
+// ---------------------------------------------------------------------------
+/** Fields likely to be boolean based on their name. */
+const BOOLEAN_FIELD_PATTERNS = [
+    /^is_/i, /^has_/i, /^can_/i, /^should_/i, /^was_/i, /^did_/i,
+    /^enabled$/i, /^disabled$/i, /^active$/i, /^visible$/i, /^archived$/i,
+    /^deleted$/i, /^verified$/i, /^confirmed$/i, /^available$/i,
+];
+/** Fields likely to be enum/status based on their name. */
+const ENUM_FIELD_PATTERNS = [
+    /status/i, /state/i, /type/i, /priority/i, /level/i,
+    /category/i, /role/i, /phase/i, /stage/i, /mode/i,
+    /result/i, /outcome/i, /decision/i, /reason/i,
+];
+/** Maximum recursion depth for JSON walkers (prevents stack overflow on deep/circular data). */
+const MAX_WALK_DEPTH = 50;
+/**
+ * Detect if a tool output looks like a DB schema description
+ * (contains "table"/"columns" keys typically returned by describe_database).
+ * These should NOT be treated as data for claim extraction.
+ */
+function isSchemaOutput(output) {
+    if (output === null || typeof output !== 'object' || Array.isArray(output))
+        return false;
+    const obj = output;
+    // describe_database typically returns { table: "...", columns: [...] }
+    return (typeof obj['table'] === 'string' || typeof obj['tables'] === 'object') &&
+        (Array.isArray(obj['columns']) || typeof obj['columns'] === 'object');
+}
+/**
+ * Walk tool output JSON and extract boolean/enum fields with their context.
+ */
+function extractStructuredFields(trace) {
+    const fields = [];
+    const steps = Trace_1.TraceUtils.getToolOutputSteps(trace);
+    for (const step of steps) {
+        for (const to of step.toolOutputs ?? []) {
+            if (isSchemaOutput(to.output))
+                continue;
+            walkOutput(to.output, step.stepId, '', fields);
+        }
+    }
+    return fields;
+}
+function walkOutput(value, stepId, path, out, depth = 0) {
+    if (value === null || value === undefined)
+        return;
+    if (depth > MAX_WALK_DEPTH)
+        return;
+    if (typeof value === 'boolean') {
+        out.push({ fieldName: path, value, stepId });
+    }
+    else if (typeof value === 'string' && path) {
+        // Check if this field name suggests boolean or enum
+        const lastKey = path.split('.').pop() ?? path;
+        const isLikelyBoolean = BOOLEAN_FIELD_PATTERNS.some((p) => p.test(lastKey));
+        const isLikelyEnum = ENUM_FIELD_PATTERNS.some((p) => p.test(lastKey));
+        if (isLikelyBoolean || isLikelyEnum || ENUM_REVERSE.has(value.toLowerCase())) {
+            out.push({ fieldName: path, value, stepId });
+        }
+    }
+    else if (typeof value === 'number') {
+        // Skip — numbers are handled by L1
+    }
+    else if (Array.isArray(value)) {
+        value.forEach((item, i) => walkOutput(item, stepId, path ? `${path}[${i}]` : `[${i}]`, out, depth + 1));
+    }
+    else if (typeof value === 'object') {
+        for (const [k, v] of Object.entries(value)) {
+            walkOutput(v, stepId, path ? `${path}.${k}` : k, out, depth + 1);
+        }
+    }
+}
+/**
+ * Extract L2 structured context claims by comparing tool output
+ * boolean/enum fields against the response text.
+ *
+ * Returns claims where the response text contains a natural-language
+ * equivalent of a structured field value.
+ */
+function extractStructuredClaims(trace, responseText, sourceStepId) {
+    if (!responseText || !trace)
+        return [];
+    const fields = extractStructuredFields(trace);
+    const claims = [];
+    const responseLower = responseText.toLowerCase();
+    const source = {
+        stepId: sourceStepId ?? 'final_response',
+        role: 'final_response',
+        rawText: responseText,
+    };
+    for (const field of fields) {
+        if (typeof field.value === 'boolean') {
+            // Boolean field — look for true/false synonyms in response
+            const boolKey = field.value ? 'true' : 'false';
+            const oppositeKey = field.value ? 'false' : 'true';
+            const matchedSynonym = findSynonymInText(responseLower, BOOLEAN_SYNONYMS[boolKey]);
+            const matchedOpposite = findSynonymInText(responseLower, BOOLEAN_SYNONYMS[oppositeKey]);
+            if (matchedSynonym) {
+                claims.push({
+                    claimId: (0, crypto_1.randomUUID)(),
+                    type: 'boolean',
+                    value: field.value ? 'true' : 'false',
+                    rawText: matchedSynonym,
+                    source,
+                    fieldName: field.fieldName,
+                    sourceFieldValue: field.value,
+                });
+            }
+            else if (matchedOpposite) {
+                // Response says the opposite of tool output — still a claim (UNGROUNDED)
+                claims.push({
+                    claimId: (0, crypto_1.randomUUID)(),
+                    type: 'boolean',
+                    value: field.value ? 'false' : 'true', // opposite of source
+                    rawText: matchedOpposite,
+                    source,
+                    fieldName: field.fieldName,
+                    sourceFieldValue: field.value,
+                });
+            }
+        }
+        else if (typeof field.value === 'string') {
+            // Enum/status field — look for value or its translations
+            const canonical = ENUM_REVERSE.get(field.value.toLowerCase()) ?? field.value.toLowerCase();
+            const synonyms = ENUM_TRANSLATIONS[canonical] ?? [field.value.toLowerCase()];
+            const matchedSynonym = findSynonymInText(responseLower, synonyms);
+            if (matchedSynonym) {
+                // Require structural proximity: the matched synonym should appear near
+                // a field-name keyword (e.g., "status: late") or be a standalone assertion,
+                // not just a verb in flowing prose (e.g., "kasni na posao" = "is late to work").
+                const synPos = responseLower.indexOf(matchedSynonym.toLowerCase());
+                const cleanKey = (field.fieldName.split('.').pop() ?? '').replace(/\[\d+\]$/, '').toLowerCase();
+                let hasFieldProximity = false;
+                if (synPos >= 0 && cleanKey.length >= 2) {
+                    // Check if the field name keyword appears within 40 chars of the synonym
+                    const nearbyStart = Math.max(0, synPos - 40);
+                    const nearbyEnd = Math.min(responseLower.length, synPos + matchedSynonym.length + 40);
+                    const nearbyText = responseLower.substring(nearbyStart, nearbyEnd);
+                    hasFieldProximity = nearbyText.includes(cleanKey);
+                }
+                // Also accept: if the field name keyword appears ANYWHERE in the response
+                // OR if the synonym is a multi-word phrase (more specific, less ambiguous)
+                // OR if the response is short (focused answer, not flowing prose)
+                const fieldMentioned = cleanKey.length >= 3 && responseLower.includes(cleanKey);
+                const isMultiWord = matchedSynonym.includes(' ');
+                const isShortResponse = responseLower.length <= 120;
+                if (hasFieldProximity || fieldMentioned || isMultiWord || isShortResponse) {
+                    claims.push({
+                        claimId: (0, crypto_1.randomUUID)(),
+                        type: 'enum',
+                        value: field.value, // original tool output value
+                        rawText: matchedSynonym,
+                        source,
+                        fieldName: field.fieldName,
+                        sourceFieldValue: field.value,
+                    });
+                }
+            }
+            else {
+                // Check if response mentions a DIFFERENT value for this field type
+                // e.g., tool says "approved" but response says "odbijen" (rejected)
+                const contradictionMatch = findContradiction(responseLower, canonical);
+                if (contradictionMatch) {
+                    claims.push({
+                        claimId: (0, crypto_1.randomUUID)(),
+                        type: 'enum',
+                        value: contradictionMatch.foundCanonical, // what response actually says
+                        rawText: contradictionMatch.foundSynonym,
+                        source,
+                        fieldName: field.fieldName,
+                        sourceFieldValue: field.value,
+                    });
+                }
+            }
+        }
+    }
+    return deduplicateClaims(claims);
+}
+/**
+ * Match a boolean claim against the tool output value.
+ */
+function matchBoolean(claimedValue, // 'true' or 'false'
+sourceValue) {
+    if (typeof sourceValue !== 'boolean') {
+        // String booleans: "true"/"false", "yes"/"no"
+        if (typeof sourceValue === 'string') {
+            const lower = sourceValue.toLowerCase();
+            if (lower === 'true' || lower === 'yes') {
+                sourceValue = true;
+            }
+            else if (lower === 'false' || lower === 'no') {
+                sourceValue = false;
+            }
+            else {
+                return { matched: false, explanation: `Source value "${sourceValue}" is not a boolean.` };
+            }
+        }
+        else {
+            return { matched: false, explanation: `Source value is not a boolean (type: ${typeof sourceValue}).` };
+        }
+    }
+    const claimedBool = claimedValue === 'true';
+    if (claimedBool === sourceValue) {
+        return { matched: true, explanation: `Boolean claim "${claimedValue}" matches source value ${sourceValue}.` };
+    }
+    return {
+        matched: false,
+        explanation: `Boolean contradiction: response indicates "${claimedValue}" but source is ${sourceValue}.`,
+    };
+}
+/**
+ * Match an enum claim against the tool output value.
+ * Uses the translation table for cross-language matching.
+ */
+function matchEnum(claimedValue, sourceValue) {
+    if (typeof sourceValue !== 'string') {
+        return { matched: false, explanation: `Source value is not a string (type: ${typeof sourceValue}).` };
+    }
+    // Direct match
+    if (claimedValue.toLowerCase() === sourceValue.toLowerCase()) {
+        return { matched: true, explanation: `Enum claim "${claimedValue}" exactly matches source "${sourceValue}".` };
+    }
+    // Translation table match: both resolve to the same canonical value
+    const claimCanonical = ENUM_REVERSE.get(claimedValue.toLowerCase()) ?? claimedValue.toLowerCase();
+    const sourceCanonical = ENUM_REVERSE.get(sourceValue.toLowerCase()) ?? sourceValue.toLowerCase();
+    if (claimCanonical === sourceCanonical) {
+        return {
+            matched: true,
+            explanation: `Enum claim "${claimedValue}" matches source "${sourceValue}" via translation (both → "${claimCanonical}").`,
+        };
+    }
+    return {
+        matched: false,
+        explanation: `Enum mismatch: response says "${claimedValue}" (→ ${claimCanonical}) but source is "${sourceValue}" (→ ${sourceCanonical}).`,
+    };
+}
+// ---------------------------------------------------------------------------
+// Public API for extending translation tables
+// ---------------------------------------------------------------------------
+/**
+ * Add custom enum translations for domain-specific values.
+ * @param translations Map of canonical_value → synonym array
+ */
+function addEnumTranslations(translations) {
+    for (const [canonical, synonyms] of Object.entries(translations)) {
+        ENUM_TRANSLATIONS[canonical] = [
+            ...(ENUM_TRANSLATIONS[canonical] ?? []),
+            ...synonyms,
+        ];
+        for (const syn of synonyms) {
+            ENUM_REVERSE.set(syn.toLowerCase(), canonical);
+        }
+    }
+}
+/**
+ * Get a copy of the current enum translation table (for testing/inspection).
+ */
+function getEnumTranslations() {
+    return { ...ENUM_TRANSLATIONS };
+}
+// =========================================================================
+// L2 — LIST ITEMS (Array Set Verification)
+// =========================================================================
+/** Field names that typically hold a displayable item label. */
+const LABEL_FIELD_PRIORITY = [
+    'name', 'full_name', 'fullName', 'display_name', 'displayName',
+    'title', 'label', 'description', 'email', 'username', 'id',
+];
+/** Check if a string looks like an ISO date (YYYY-MM-DD). */
+function isDateLikeKey(key) {
+    return /^\d{4}-\d{2}-\d{2}$/.test(key);
+}
+/**
+ * Parse a period string (from TraceUtils.inferPeriod) into concrete start/end dates.
+ * Returns null if the period cannot be parsed.
+ */
+function parsePeriodBounds(period) {
+    if (!period)
+        return null;
+    // Range format: "2026-03-01/2026-03-31"
+    if (period.includes('/')) {
+        const [start, end] = period.split('/');
+        if (/^\d{4}-\d{2}-\d{2}$/.test(start) && /^\d{4}-\d{2}-\d{2}$/.test(end)) {
+            return { start, end };
+        }
+    }
+    // Single date: "2026-03-02"
+    if (/^\d{4}-\d{2}-\d{2}$/.test(period)) {
+        return { start: period, end: period };
+    }
+    return null;
+}
+/**
+ * Walk all tool outputs to find arrays of objects and extract their display labels.
+ * After basic extraction, flat arrays whose items have a date field are split
+ * into date-based sub-groups so that sibling-scope filtering can treat each
+ * date slice independently (same logic as keyed containers).
+ */
+function extractArrayGroups(trace, period) {
+    const groups = [];
+    const steps = Trace_1.TraceUtils.getToolOutputSteps(trace);
+    const periodBounds = parsePeriodBounds(period);
+    for (const step of steps) {
+        for (const to of step.toolOutputs ?? []) {
+            if (isSchemaOutput(to.output))
+                continue;
+            walkForArrays(to.output, step.stepId, '', groups, 0, periodBounds);
+        }
+    }
+    // Post-process: split flat arrays by date field when items contain one.
+    // E.g. [{date:"2026-03-02",name:"Vladimir"},{date:"2026-03-14",name:"Dejan"}]
+    // → two sub-groups: path.date=2026-03-02 and path.date=2026-03-14
+    return splitDateFieldGroups(groups, trace);
+}
+const DATE_FIELD_NAMES = ['date', 'datum', 'day', 'dan', 'event_date', 'created_at', 'timestamp'];
+const DATE_VALUE_RE = /^\d{4}-\d{2}-\d{2}/;
+/**
+ * For flat arrays whose items have a date field, split the single ArrayGroup
+ * into per-date sub-groups. This allows the sibling-scope machinery to treat
+ * each date slice independently.
+ *
+ * Example: array at path "anomalies" with items spanning 3 dates →
+ *   anomalies.date=2026-03-02, anomalies.date=2026-03-14, anomalies.date=2026-03-15
+ */
+function splitDateFieldGroups(groups, trace) {
+    const toolSteps = Trace_1.TraceUtils.getToolOutputSteps(trace);
+    const result = [];
+    for (const group of groups) {
+        // Find the raw array from tool output to inspect its items' date fields
+        const rawArray = findRawArray(group, toolSteps);
+        if (!rawArray || rawArray.length < 2) {
+            result.push(group);
+            continue;
+        }
+        // Check if items have a date field
+        const dateField = DATE_FIELD_NAMES.find((f) => {
+            const sample = rawArray[0];
+            return typeof sample[f] === 'string' && DATE_VALUE_RE.test(sample[f]);
+        });
+        if (!dateField) {
+            result.push(group);
+            continue;
+        }
+        // Group items by date value
+        const byDate = new Map();
+        for (let i = 0; i < rawArray.length; i++) {
+            const item = rawArray[i];
+            const dateVal = item[dateField];
+            if (!dateVal)
+                continue;
+            const dateKey = dateVal.substring(0, 10); // YYYY-MM-DD
+            const label = group.labels[i];
+            if (!label)
+                continue;
+            if (!byDate.has(dateKey))
+                byDate.set(dateKey, []);
+            byDate.get(dateKey).push(label);
+        }
+        // Only split if there are multiple date values (otherwise no benefit)
+        if (byDate.size < 2) {
+            result.push(group);
+            continue;
+        }
+        for (const [dateKey, labels] of byDate) {
+            result.push({
+                arrayPath: `${group.arrayPath}.${dateField}=${dateKey}`,
+                labels,
+                stepId: group.stepId,
+            });
+        }
+    }
+    return result;
+}
+/**
+ * Find the raw array in tool outputs that corresponds to an ArrayGroup.
+ */
+function findRawArray(group, steps) {
+    for (const step of steps) {
+        if (step.stepId !== group.stepId)
+            continue;
+        for (const to of step.toolOutputs ?? []) {
+            const found = resolveArrayPath(to.output, group.arrayPath);
+            if (found)
+                return found;
+        }
+    }
+    return null;
+}
+function resolveArrayPath(root, path) {
+    if (!path || path === 'root') {
+        return Array.isArray(root) ? root : null;
+    }
+    const segments = path.split('.');
+    let current = root;
+    for (const seg of segments) {
+        if (current === null || current === undefined)
+            return null;
+        if (typeof current !== 'object')
+            return null;
+        current = current[seg];
+    }
+    return Array.isArray(current) ? current : null;
+}
+function walkForArrays(value, stepId, path, out, depth = 0, periodBounds) {
+    if (value === null || value === undefined)
+        return;
+    if (depth > MAX_WALK_DEPTH)
+        return;
+    if (Array.isArray(value) && value.length > 0 && typeof value[0] === 'object' && value[0] !== null) {
+        // Array of objects — extract labels
+        const labels = [];
+        for (const item of value) {
+            if (typeof item !== 'object' || item === null)
+                continue;
+            const obj = item;
+            const label = pickLabel(obj);
+            if (label)
+                labels.push(label);
+        }
+        if (labels.length > 0) {
+            out.push({ arrayPath: path || 'root', labels, stepId });
+        }
+        // Also recurse into each item for nested arrays
+        value.forEach((item, i) => walkForArrays(item, stepId, path ? `${path}[${i}]` : `[${i}]`, out, depth + 1, periodBounds));
+    }
+    else if (typeof value === 'object' && !Array.isArray(value)) {
+        const entries = Object.entries(value);
+        // Detect date-keyed containers (e.g. by_date: { "2026-03-02": {...}, "2026-03-15": {...} })
+        // When a period is known, only descend into date keys within that period.
+        const dateKeyCount = entries.filter(([k]) => isDateLikeKey(k)).length;
+        const isDateKeyedContainer = dateKeyCount > 0 && dateKeyCount >= entries.length * 0.5;
+        for (const [k, v] of entries) {
+            if (isDateKeyedContainer && isDateLikeKey(k) && periodBounds) {
+                // Skip date keys outside the requested period
+                if (k < periodBounds.start || k > periodBounds.end)
+                    continue;
+            }
+            walkForArrays(v, stepId, path ? `${path}.${k}` : k, out, depth + 1, periodBounds);
+        }
+    }
+}
+/** Pick the best display label from an object by field priority. */
+function pickLabel(obj) {
+    for (const field of LABEL_FIELD_PRIORITY) {
+        if (typeof obj[field] === 'string' && obj[field])
+            return obj[field];
+    }
+    // Fallback: first string field
+    for (const val of Object.values(obj)) {
+        if (typeof val === 'string' && val.length > 0 && val.length < 100)
+            return val;
+    }
+    return null;
+}
+/**
+ * Extract list_items claims: for each array in tool output, check which
+ * items the response mentions and which it omits.
+ *
+ * Sibling-scope relevance filtering: when tool output contains a keyed
+ * container (e.g. by_date, by_employee, by_location — any `parent.<dynamic_key>.leaf`
+ * pattern), the user typically asks about a subset.  We detect "sibling families"
+ * — groups whose paths differ in exactly one segment — and classify each group's
+ * activation strength:
+ *   strong  — ≥2 labels mentioned in the response
+ *   weak    — exactly 1 label mentioned
+ *   dormant — 0 labels mentioned
+ *
+ * When at least one sibling is strong/weak, dormant siblings are suppressed.
+ * When only weak siblings exist among active ones, they are marked `weak_scope`.
+ * When ALL siblings are dormant, everything is kept (possible data_ignored).
+ */
+function extractListItemsClaims(trace, responseText, sourceStepId) {
+    if (!responseText || !trace)
+        return [];
+    const period = Trace_1.TraceUtils.inferPeriod(trace);
+    const groups = extractArrayGroups(trace, period);
+    const claims = [];
+    const responseLower = responseText.toLowerCase();
+    const source = {
+        stepId: sourceStepId ?? 'final_response',
+        role: 'final_response',
+        rawText: responseText,
+    };
+    // -----------------------------------------------------------------------
+    // Sibling-scope relevance filtering
+    // -----------------------------------------------------------------------
+    const siblingFamilies = groupSiblingFamilies(groups);
+    // Map: arrayPath → { scope, familyPattern }
+    const scopeMap = new Map();
+    for (const family of siblingFamilies) {
+        if (family.groups.length < 2)
+            continue; // Not a true family
+        const activations = [];
+        for (const group of family.groups) {
+            const mentionCount = group.labels.filter((label) => isLabelMentioned(responseLower, label)).length;
+            const strength = mentionCount >= 2 ? 'strong' :
+                mentionCount === 1 ? 'weak' :
+                    'dormant';
+            activations.push({ group, strength, mentionCount });
+        }
+        const hasStrong = activations.some((a) => a.strength === 'strong');
+        const hasWeak = activations.some((a) => a.strength === 'weak');
+        const allDormant = activations.every((a) => a.strength === 'dormant');
+        if (allDormant) {
+            // All dormant → keep everything (possible data_ignored)
+            for (const a of activations) {
+                scopeMap.set(a.group.arrayPath, { scope: 'in_scope', familyPattern: family.pattern });
+            }
+        }
+        else {
+            // At least one active sibling exists
+            for (const a of activations) {
+                if (a.strength === 'strong') {
+                    scopeMap.set(a.group.arrayPath, { scope: 'in_scope', familyPattern: family.pattern });
+                }
+                else if (a.strength === 'weak') {
+                    // Weak activation: if there's also a strong sibling, this is weak_scope;
+                    // if this is the strongest signal, it's in_scope
+                    const scope = hasStrong ? 'weak_scope' : 'in_scope';
+                    scopeMap.set(a.group.arrayPath, { scope, familyPattern: family.pattern });
+                }
+                else {
+                    // Dormant: suppress when any sibling is active
+                    scopeMap.set(a.group.arrayPath, { scope: 'suppressed', familyPattern: family.pattern });
+                }
+            }
+        }
+    }
+    for (const group of groups) {
+        if (group.labels.length < 2)
+            continue; // Single items don't need set verification
+        const scopeInfo = scopeMap.get(group.arrayPath);
+        // Hard-skip suppressed siblings (no claims generated)
+        if (scopeInfo?.scope === 'suppressed')
+            continue;
+        const mentioned = [];
+        const missing = [];
+        for (const label of group.labels) {
+            if (isLabelMentioned(responseLower, label)) {
+                mentioned.push(label);
+            }
+            else {
+                missing.push(label);
+            }
+        }
+        // Only create a claim if the response mentions at least one item (shows it's discussing the list)
+        if (mentioned.length > 0) {
+            const claim = {
+                claimId: (0, crypto_1.randomUUID)(),
+                type: 'list_items',
+                value: mentioned.join(', '),
+                rawText: responseText.substring(0, 200),
+                source,
+                fieldName: group.arrayPath,
+                sourceFieldValue: group.labels,
+                expectedItems: group.labels,
+                mentionedItems: mentioned,
+            };
+            // Attach sibling-scope metadata when applicable
+            if (scopeInfo) {
+                claim.siblingScope = scopeInfo.scope;
+                claim.siblingFamilyPattern = scopeInfo.familyPattern;
+            }
+            claims.push(claim);
+        }
+    }
+    return claims;
+}
+/**
+ * Detect sibling families: groups of ArrayGroups whose paths differ in exactly
+ * one segment (the dynamic key).  Works for ANY keyed container pattern:
+ *   by_date.2026-03-02.people  → by_date.*.people
+ *   by_employee.123.sessions   → by_employee.*.sessions
+ *   by_location.NS-01.people   → by_location.*.people
+ *   weeks.2026-W10.items       → weeks.*.items
+ *
+ * Algorithm: for each group, try wildcarding each path segment; groups that
+ * map to the same pattern form a family.  Each group is assigned to at most
+ * one family (largest match wins).
+ */
+function groupSiblingFamilies(groups) {
+    // Build candidate families: pattern → { segmentIdx, arrayPaths }
+    const candidateMap = new Map();
+    for (const group of groups) {
+        const segments = group.arrayPath.split('.');
+        for (let i = 0; i < segments.length; i++) {
+            // Skip array index segments (e.g. "[0]", "items[2]")
+            if (/\[\d+\]/.test(segments[i]))
+                continue;
+            // Guard: don't wildcard the first or last segment of a multi-segment path.
+            // Wildcarding segment 0 would merge semantically different root containers
+            // (e.g. "summary.by_loc.NS.people" + "details.by_loc.NS.people" → "*.by_loc.NS.people").
+            // Wildcarding the leaf would merge structurally different array types.
+            // Only interior segments (dynamic keys between a container prefix and a leaf) are valid.
+            if (segments.length >= 3 && (i === 0 || i === segments.length - 1))
+                continue;
+            const pattern = segments.map((s, j) => (j === i ? '*' : s)).join('.');
+            let entry = candidateMap.get(pattern);
+            if (!entry) {
+                entry = { segmentIdx: i, paths: new Set() };
+                candidateMap.set(pattern, entry);
+            }
+            entry.paths.add(group.arrayPath);
+        }
+    }
+    // Keep only patterns with 2+ distinct members → real families
+    const candidates = [...candidateMap.entries()]
+        .filter(([, v]) => v.paths.size >= 2)
+        .sort(([, a], [, b]) => b.paths.size - a.paths.size); // prefer larger families
+    // Assign each group to at most one family (largest first → greedy)
+    const assigned = new Set();
+    const groupMap = new Map(groups.map((g) => [g.arrayPath, g]));
+    const families = [];
+    for (const [pattern, { segmentIdx }] of candidates) {
+        const members = [];
+        for (const path of candidateMap.get(pattern).paths) {
+            if (assigned.has(path))
+                continue;
+            const g = groupMap.get(path);
+            if (g)
+                members.push(g);
+        }
+        if (members.length < 2)
+            continue;
+        families.push({ pattern, segmentIdx, groups: members });
+        for (const m of members)
+            assigned.add(m.arrayPath);
+    }
+    return families;
+}
+/** Check if a label appears in the response (supports multi-word and partial name matching). */
+function isLabelMentioned(responseLower, label) {
+    const labelLower = label.toLowerCase();
+    // Direct presence
+    if (responseLower.includes(labelLower))
+        return true;
+    // For multi-word names, check if the last name or first name alone appears
+    const parts = labelLower.split(/\s+/);
+    if (parts.length >= 2) {
+        // Check last name (more unique) — e.g. "Jovic" from "Ana Jovic"
+        if (parts[parts.length - 1].length >= 3) {
+            const re = new RegExp(`\\b${escapeRegex(parts[parts.length - 1])}\\b`, 'i');
+            if (re.test(responseLower))
+                return true;
+        }
+    }
+    return false;
+}
+/**
+ * Match a list_items claim: verify completeness of list mention.
+ */
+function matchListItems(expectedItems, mentionedItems) {
+    if (expectedItems.length === 0) {
+        return { matched: true, explanation: 'Empty list — nothing to verify.' };
+    }
+    // Use diacritics-insensitive comparison for name lists
+    const norm = (s) => s.normalize('NFD').replace(/[\u0300-\u036f]/g, '').toLowerCase().trim();
+    const missing = expectedItems.filter((e) => !mentionedItems.some((m) => norm(m) === norm(e)));
+    if (missing.length === 0) {
+        return {
+            matched: true,
+            explanation: `All ${expectedItems.length} items mentioned in response: ${expectedItems.join(', ')}.`,
+        };
+    }
+    // High-coverage partial match: if ≥90% of items are mentioned, treat as GROUNDED.
+    // This handles cases where 16/17 names are listed but one has a minor spelling difference.
+    const matched = expectedItems.length - missing.length;
+    const coverage = matched / expectedItems.length;
+    if (coverage >= 0.9 && missing.length <= 2) {
+        return {
+            matched: true,
+            explanation: `Near-complete list: ${matched}/${expectedItems.length} items mentioned (${(coverage * 100).toFixed(0)}%). Minor omission: ${missing.join(', ')}.`,
+        };
+    }
+    return {
+        matched: false,
+        explanation: `Incomplete list: ${matched}/${expectedItems.length} items mentioned. Missing: ${missing.join(', ')}. Coverage: ${(coverage * 100).toFixed(0)}%.`,
+    };
+}
+// =========================================================================
+// L2 — KEY-VALUE Pair Matching
+// =========================================================================
+/** Patterns for field names that hold identifiers or contact info. */
+const KEY_VALUE_FIELD_PATTERNS = [
+    /email/i, /e_mail/i, /phone/i, /tel/i, /mobile/i, /fax/i,
+    /id$/i, /^id_/i, /code/i, /iban/i, /account/i, /number$/i,
+    /url/i, /link/i, /website/i, /address/i,
+    /jmbg/i, /pib/i, /matični/i, /maticni/i, /mbr/i,
+    /license/i, /registration/i,
+];
+/**
+ * Walk tool outputs and extract key-value pairs that are identifiers,
+ * contact info, or codes (not already covered by L1 name/number matching).
+ */
+function extractKeyValueFields(trace) {
+    const fields = [];
+    const steps = Trace_1.TraceUtils.getToolOutputSteps(trace);
+    for (const step of steps) {
+        for (const to of step.toolOutputs ?? []) {
+            if (isSchemaOutput(to.output))
+                continue;
+            walkForKeyValues(to.output, step.stepId, '', fields);
+        }
+    }
+    return fields;
+}
+function walkForKeyValues(value, stepId, path, out, depth = 0) {
+    if (value === null || value === undefined)
+        return;
+    if (depth > MAX_WALK_DEPTH)
+        return;
+    if (typeof value === 'string' && path) {
+        const lastKey = (path.split('.').pop() ?? path).replace(/\[\d+\]$/, '');
+        const isKeyValue = KEY_VALUE_FIELD_PATTERNS.some((p) => p.test(lastKey));
+        if (isKeyValue && value.length > 0 && value.length < 200) {
+            out.push({ fieldName: path, key: lastKey, value, stepId });
+        }
+    }
+    else if (Array.isArray(value)) {
+        value.forEach((item, i) => walkForKeyValues(item, stepId, path ? `${path}[${i}]` : `[${i}]`, out, depth + 1));
+    }
+    else if (typeof value === 'object') {
+        for (const [k, v] of Object.entries(value)) {
+            walkForKeyValues(v, stepId, path ? `${path}.${k}` : k, out, depth + 1);
+        }
+    }
+}
+/**
+ * Extract key_value claims: check if identifiers from tool output appear in the response.
+ */
+function extractKeyValueClaims(trace, responseText, sourceStepId) {
+    if (!responseText || !trace)
+        return [];
+    const fields = extractKeyValueFields(trace);
+    const claims = [];
+    const responseLower = responseText.toLowerCase();
+    const source = {
+        stepId: sourceStepId ?? 'final_response',
+        role: 'final_response',
+        rawText: responseText,
+    };
+    for (const field of fields) {
+        const valueLower = field.value.toLowerCase();
+        // Check if the value (or something close) appears in the response
+        if (responseLower.includes(valueLower)) {
+            // Exact match — claim that the value is correct
+            claims.push({
+                claimId: (0, crypto_1.randomUUID)(),
+                type: 'key_value',
+                value: field.value,
+                rawText: field.value,
+                source,
+                fieldName: field.fieldName,
+                sourceFieldValue: field.value,
+            });
+        }
+        else {
+            // Check for "near-miss" — response contains something similar to the value
+            // This catches cases where LLM alters an ID or email slightly
+            const nearMiss = findNearMissInResponse(responseLower, valueLower, field.key);
+            if (nearMiss) {
+                claims.push({
+                    claimId: (0, crypto_1.randomUUID)(),
+                    type: 'key_value',
+                    value: nearMiss, // what response actually says
+                    rawText: nearMiss,
+                    source,
+                    fieldName: field.fieldName,
+                    sourceFieldValue: field.value,
+                });
+            }
+        }
+    }
+    return deduplicateClaims(claims);
+}
+/**
+ * Try to find a near-miss value in the response for a key-value field.
+ * E.g., if source has "ana@company.com" but response says "ana@company.rs".
+ */
+function findNearMissInResponse(responseLower, valueLower, fieldKey) {
+    // For emails: look for @domain patterns
+    if (/email|e_mail/i.test(fieldKey)) {
+        const emailPattern = /[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}/g;
+        const matches = responseLower.match(emailPattern);
+        if (matches) {
+            for (const m of matches) {
+                if (m !== valueLower && m.length > 3)
+                    return m;
+            }
+        }
+    }
+    // For phone numbers: look for phone-like patterns
+    if (/phone|tel|mobile|fax/i.test(fieldKey)) {
+        const phonePattern = /[+]?\d[\d\s\-()]{6,}/g;
+        const matches = responseLower.match(phonePattern);
+        if (matches) {
+            const sourceDigits = valueLower.replace(/\D/g, '');
+            for (const m of matches) {
+                const respDigits = m.replace(/\D/g, '');
+                if (respDigits.length >= 6 && respDigits !== sourceDigits)
+                    return m.trim();
+            }
+        }
+    }
+    // For IDs/codes: look for alphanumeric patterns of similar length
+    if (/id$|^id_|code|iban|account|number$/i.test(fieldKey)) {
+        // Search for a token in the response that's similar in structure
+        const idPattern = /[A-Za-z0-9\-_.]{3,}/g;
+        const matches = responseLower.match(idPattern);
+        if (matches) {
+            for (const m of matches) {
+                // Same prefix but different — likely a mutated ID
+                if (m !== valueLower && m.length >= valueLower.length - 2 && m.length <= valueLower.length + 2) {
+                    const commonPrefix = commonPrefixLength(m, valueLower);
+                    if (commonPrefix >= Math.min(3, valueLower.length * 0.5))
+                        return m;
+                }
+            }
+        }
+    }
+    return null;
+}
+function commonPrefixLength(a, b) {
+    let i = 0;
+    while (i < a.length && i < b.length && a[i] === b[i])
+        i++;
+    return i;
+}
+/**
+ * Match a key_value claim against the tool output value.
+ * Exact string comparison for identifiers.
+ */
+function matchKeyValue(claimedValue, sourceValue) {
+    if (typeof sourceValue !== 'string') {
+        return { matched: false, explanation: `Source value is not a string (type: ${typeof sourceValue}).` };
+    }
+    // Exact match (case-insensitive for most IDs)
+    if (claimedValue.toLowerCase() === sourceValue.toLowerCase()) {
+        return { matched: true, explanation: `Key-value "${claimedValue}" exactly matches source "${sourceValue}".` };
+    }
+    // For phone numbers, normalize and compare digits only
+    const claimedDigits = claimedValue.replace(/\D/g, '');
+    const sourceDigits = sourceValue.replace(/\D/g, '');
+    if (claimedDigits.length >= 6 && sourceDigits.length >= 6 && claimedDigits === sourceDigits) {
+        return { matched: true, explanation: `Phone digits match: "${claimedValue}" ≡ "${sourceValue}" (same digits).` };
+    }
+    return {
+        matched: false,
+        explanation: `Key-value mismatch: response says "${claimedValue}" but source is "${sourceValue}".`,
+    };
+}
+// =========================================================================
+// L2 — AGGREGATION Verification
+// =========================================================================
+/** Field names likely to be numeric and aggregatable. */
+const NUMERIC_AGGREGATABLE_PATTERNS = [
+    /hours?/i, /amount/i, /total/i, /price/i, /cost/i, /salary/i,
+    /balance/i, /quantity/i, /count/i, /score/i, /rating/i,
+    /duration/i, /distance/i, /weight/i, /age/i, /payment/i,
+    /budget/i, /revenue/i, /profit/i, /loss/i, /expense/i,
+    /minutes?/i, /tardiness/i, /lateness/i, /overtime/i, /absence/i,
+];
+/** Words in response that suggest an aggregation was performed. */
+const AGGREGATION_KEYWORDS = {
+    sum: [
+        /\btotal\b/i, /\bukupno\b/i, /\bsum\b/i, /\bzbir\b/i, /\bsuma\b/i,
+        /\bsve zajedno\b/i, /\ball together\b/i,
+    ],
+    avg: [
+        /\baverage\b/i, /\bprosek\b/i, /\bprosečn/i, /\bprosecn/i, /\bmean\b/i,
+        /\bavg\b/i, /\bpo (osobi|zaposlenom|članu)/i,
+    ],
+    count: [
+        /\bcount\b/i, /\bbroj\b/i, /\bima\s+\d+/i, /\bthere\s+(are|is)\s+\d+/i,
+        /\bukupno\s+\d+/i,
+    ],
+    count_distinct: [
+        /\brazličit/i, /\brazlicit/i, /\bdistinct\b/i, /\bunique\b/i,
+        /\bjedinstven/i, /\bposebnih\b/i,
+    ],
+    min: [
+        /\bminimum\b/i, /\bmin\b/i, /\bnajmanj/i, /\blowest\b/i, /\bnajniž/i, /\bnajniz/i,
+    ],
+    max: [
+        /\bmaximum\b/i, /\bmax\b/i, /\bnajveć/i, /\bnajvec/i, /\bhighest\b/i, /\bnajviš/i, /\bnajvis/i,
+    ],
+    pct_of_total: [
+        /\b(\d+(?:[.,]\d+)?)\s*%\s*(?:of|od|от|de|des|di|из)\b/i,
+        /\budeo\b/i, /\bučešće\b/i, /\bucešce\b/i, /\bučesce\b/i,
+        /\bshare\b/i, /\bproportion\b/i, /\bpercentage\b/i,
+        /\bodnos\b/i, /\brazmera\b/i,
+        /\bдоля\b/i, /\bпроцент\b/i,
+        /\bporcentaje\b/i, /\bporcentagem\b/i,
+    ],
+};
+/**
+ * Walk tool outputs and find arrays of objects with numeric fields.
+ */
+function extractNumericArrays(trace) {
+    const arrays = [];
+    const steps = Trace_1.TraceUtils.getToolOutputSteps(trace);
+    for (const step of steps) {
+        for (const to of step.toolOutputs ?? []) {
+            findNumericArrays(to.output, step.stepId, arrays);
+        }
+    }
+    return arrays;
+}
+function findNumericArrays(value, stepId, out, depth = 0) {
+    if (depth > MAX_WALK_DEPTH)
+        return;
+    if (!Array.isArray(value) || value.length === 0) {
+        // Recurse into objects to find nested arrays
+        if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
+            for (const v of Object.values(value)) {
+                findNumericArrays(v, stepId, out, depth + 1);
+            }
+        }
+        return;
+    }
+    // Check if it's an array of objects
+    if (typeof value[0] !== 'object' || value[0] === null)
+        return;
+    // Find numeric fields across all items
+    const fieldValues = new Map();
+    for (const item of value) {
+        if (typeof item !== 'object' || item === null)
+            continue;
+        for (const [k, v] of Object.entries(item)) {
+            // Accept numbers directly, and numeric strings (e.g. "58" from DB queries)
+            let numVal;
+            if (typeof v === 'number' && !Number.isNaN(v)) {
+                numVal = v;
+            }
+            else if (typeof v === 'string' && /^-?\d+(\.\d+)?$/.test(v.trim())) {
+                numVal = parseFloat(v.trim());
+            }
+            if (numVal !== undefined) {
+                const isAggregatable = NUMERIC_AGGREGATABLE_PATTERNS.some((p) => p.test(k));
+                if (isAggregatable) {
+                    if (!fieldValues.has(k))
+                        fieldValues.set(k, []);
+                    fieldValues.get(k).push(numVal);
+                }
+            }
+        }
+    }
+    for (const [fieldName, values] of fieldValues) {
+        if (values.length >= 2) {
+            out.push({ fieldName, values, stepId });
+        }
+    }
+    // Recurse into items for nested arrays
+    for (const item of value) {
+        if (typeof item === 'object' && item !== null) {
+            for (const v of Object.values(item)) {
+                findNumericArrays(v, stepId, out, depth + 1);
+            }
+        }
+    }
+}
+function computeAggregation(values, op) {
+    switch (op) {
+        case 'sum': return values.reduce((a, b) => a + b, 0);
+        case 'avg': return values.reduce((a, b) => a + b, 0) / values.length;
+        case 'count': return values.length;
+        case 'count_distinct': return new Set(values).size;
+        case 'min': return Math.min(...values);
+        case 'max': return Math.max(...values);
+        case 'pct_of_total': {
+            // Returns the percentage of the first value relative to the total.
+            // Used when response asks "what % is X of total".
+            const total = values.reduce((a, b) => a + b, 0);
+            return total === 0 ? 0 : (values[0] / total) * 100;
+        }
+    }
+}
+/**
+ * Extract numbers from response text that might be aggregation results.
+ * Filters out list ordinals (e.g. "14." at the start of a line) to avoid
+ * treating numbered-list markers as aggregation claims.
+ */
+function extractNumbersFromResponse(text) {
+    // Match European dot-thousands (1.234.567), comma/dot decimals, or plain integers
+    const pattern = /(?<!\w)(\d{1,3}(?:\.\d{3})+|\d+(?:[.,]\d+)?)(?!\w)/g;
+    // European-style thousand separator: X.XXX (dot + exactly 3 digits, repeatable)
+    const dotThousands = /^\d{1,3}(?:\.\d{3})+$/;
+    const numbers = [];
+    let match;
+    while ((match = pattern.exec(text)) !== null) {
+        const raw = match[1];
+        // Skip list ordinals: "1." / "14." at the start of a line
+        if (isListOrdinal(text, match.index, match.index + raw.length))
+            continue;
+        const num = dotThousands.test(raw)
+            ? parseFloat(raw.replace(/\./g, '')) // "4.496" → 4496
+            : parseFloat(raw.replace(',', '.')); // "4,5" → 4.5
+        if (!Number.isNaN(num))
+            numbers.push(num);
+    }
+    return numbers;
+}
+/**
+ * Returns true if the number at [start, end) is a list ordinal marker,
+ * e.g. "14." at the beginning of a line or "14." in an inline numbered list.
+ */
+function isListOrdinal(text, start, end) {
+    // Must be followed by '.' then whitespace or end-of-string
+    const after = text.substring(end, end + 2);
+    if (!/^\.\s/.test(after) && !/^\.$/.test(after))
+        return false;
+    // Case 1: at the start of a line (or start of text)
+    if (start === 0)
+        return true;
+    const before = text.substring(Math.max(0, start - 5), start);
+    if (/(?:^|\n)\s*(?:[*\->]\s*)?\**$/.test(before))
+        return true;
+    // Case 2: inline list — preceded by comma/semicolon + space, or " - "
+    // Matches patterns like: "1. Ivan, 2. Milan, 14. Goran"
+    if (/[,;]\s*$/.test(before)) {
+        // Verify this is part of a numbered sequence: look for another "N." nearby
+        const contextStart = Math.max(0, start - 80);
+        const context = text.substring(contextStart, start);
+        if (/\b\d{1,3}\.\s/.test(context))
+            return true;
+    }
+    return false;
+}
+/**
+ * Detect which aggregation operation the response describes and verify it.
+ */
+function extractAggregationClaims(trace, responseText, sourceStepId) {
+    if (!responseText || !trace)
+        return [];
+    const numArrays = extractNumericArrays(trace);
+    if (numArrays.length === 0)
+        return [];
+    const claims = [];
+    const responseLower = responseText.toLowerCase();
+    const responseNumbers = extractNumbersFromResponse(responseText);
+    const source = {
+        stepId: sourceStepId ?? 'final_response',
+        role: 'final_response',
+        rawText: responseText,
+    };
+    // Build a global set of all individual values across ALL arrays.
+    // Used to exclude data points that appear as raw values from being
+    // misidentified as wrong aggregation attempts.
+    const allIndividualValues = new Set();
+    for (const arr of numArrays) {
+        for (const v of arr.values)
+            allIndividualValues.add(v);
+    }
+    // Also include scalar aggregate fields (total, count, etc.) from tool outputs.
+    // Without this, a direct quote like "total: 35" could be flagged as a wrong
+    // aggregation when a different array happens to sum to a nearby value.
+    for (const step of Trace_1.TraceUtils.getToolOutputSteps(trace)) {
+        for (const to of step.toolOutputs ?? []) {
+            const cnt = (0, Matchers_1.extractCountFromOutput)(to.output);
+            if (cnt !== null)
+                allIndividualValues.add(cnt);
+        }
+    }
+    for (const arr of numArrays) {
+        // Detect which aggregation operation the response is performing
+        for (const [op, patterns] of Object.entries(AGGREGATION_KEYWORDS)) {
+            const opMatched = patterns.some((p) => p.test(responseLower));
+            if (!opMatched)
+                continue;
+            const aggOp = op;
+            const correctValue = computeAggregation(arr.values, aggOp);
+            // Check if the response contains a number that could be this aggregation
+            for (const respNum of responseNumbers) {
+                // Is this number close to any aggregation result?
+                const tolerance = aggOp === 'avg' ? 0.1 : 0.01;
+                const diff = Math.abs(respNum - correctValue);
+                const relDiff = correctValue !== 0 ? diff / Math.abs(correctValue) : diff;
+                if (relDiff <= tolerance || diff < 0.5) {
+                    // Response has the correct (or close) aggregation
+                    claims.push({
+                        claimId: (0, crypto_1.randomUUID)(),
+                        type: 'aggregation',
+                        value: respNum,
+                        rawText: String(respNum),
+                        source,
+                        fieldName: arr.fieldName,
+                        sourceFieldValue: arr.values,
+                        aggregationOp: aggOp,
+                        computedValue: correctValue,
+                    });
+                }
+                else if (isPlausibleAggregation(respNum, arr.values, aggOp)) {
+                    // Skip numbers that exist as direct field values in ANY array —
+                    // these are individual data points, not wrong aggregation attempts.
+                    // E.g., break_count=70 for one employee ≠ avg of all break_counts.
+                    // Check all arrays (not just current) to prevent cross-array FPs.
+                    if (allIndividualValues.has(respNum))
+                        continue;
+                    // Response has a wrong aggregation — still create claim so it gets flagged
+                    claims.push({
+                        claimId: (0, crypto_1.randomUUID)(),
+                        type: 'aggregation',
+                        value: respNum,
+                        rawText: String(respNum),
+                        source,
+                        fieldName: arr.fieldName,
+                        sourceFieldValue: arr.values,
+                        aggregationOp: aggOp,
+                        computedValue: correctValue,
+                    });
+                }
+            }
+        }
+    }
+    // -----------------------------------------------------------------------
+    // Implicit aggregation: no keyword present, but a response number matches
+    // a computed aggregation (sum or avg) and does NOT match any individual
+    // data point. This catches cases like "160" appearing in the response
+    // when the tool data sums to 160 but no "total"/"ukupno" keyword is used.
+    // -----------------------------------------------------------------------
+    if (claims.length === 0) {
+        // allIndividualValues already built above
+        for (const arr of numArrays) {
+            if (arr.values.length < 2)
+                continue;
+            // Only try sum and avg for implicit detection (count/min/max too likely to collide)
+            const implicitOps = ['sum', 'avg'];
+            for (const op of implicitOps) {
+                const correctValue = computeAggregation(arr.values, op);
+                if (correctValue === 0)
+                    continue;
+                for (const respNum of responseNumbers) {
+                    // Skip if this number appears as an individual data point
+                    if (allIndividualValues.has(respNum))
+                        continue;
+                    const tolerance = op === 'avg' ? 0.1 : 0.01;
+                    const diff = Math.abs(respNum - correctValue);
+                    const relDiff = diff / Math.abs(correctValue);
+                    if (relDiff <= tolerance || diff < 0.5) {
+                        claims.push({
+                            claimId: (0, crypto_1.randomUUID)(),
+                            type: 'aggregation',
+                            value: respNum,
+                            rawText: String(respNum),
+                            source,
+                            fieldName: arr.fieldName,
+                            sourceFieldValue: arr.values,
+                            aggregationOp: op,
+                            computedValue: correctValue,
+                        });
+                    }
+                    else if (isPlausibleAggregation(respNum, arr.values, op)) {
+                        // Wrong implicit aggregation
+                        if (allIndividualValues.has(respNum))
+                            continue;
+                        claims.push({
+                            claimId: (0, crypto_1.randomUUID)(),
+                            type: 'aggregation',
+                            value: respNum,
+                            rawText: String(respNum),
+                            source,
+                            fieldName: arr.fieldName,
+                            sourceFieldValue: arr.values,
+                            aggregationOp: op,
+                            computedValue: correctValue,
+                        });
+                    }
+                }
+            }
+        }
+    }
+    // Value-level dedup: when the same response number creates claims against
+    // multiple arrays, keep only the claim with the smallest deviation from
+    // its computed value. This prevents cross-array false positives (e.g.,
+    // "39" correctly matching count array sum but also wrongly matching
+    // as a plausible aggregation of a tardiness array).
+    const bestByValue = new Map();
+    for (const c of claims) {
+        const val = c.value;
+        const existing = bestByValue.get(val);
+        if (!existing) {
+            bestByValue.set(val, c);
+            continue;
+        }
+        const existingDiff = existing.computedValue !== undefined
+            ? Math.abs(val - existing.computedValue) / (Math.abs(existing.computedValue) || 1)
+            : Infinity;
+        const newDiff = c.computedValue !== undefined
+            ? Math.abs(val - c.computedValue) / (Math.abs(c.computedValue) || 1)
+            : Infinity;
+        if (newDiff < existingDiff) {
+            bestByValue.set(val, c);
+        }
+    }
+    const dedupedClaims = [...bestByValue.values()];
+    return deduplicateClaims(dedupedClaims);
+}
+/**
+ * Check if a number is a plausible (but wrong) aggregation of the values.
+ * E.g., if sum is 113 but response says 120, it's likely a math error.
+ */
+function isPlausibleAggregation(respNum, values, op) {
+    const correct = computeAggregation(values, op);
+    if (correct === 0)
+        return false;
+    const relDiff = Math.abs(respNum - correct) / Math.abs(correct);
+    // Within 30% of the correct value — likely a math error, not random number
+    if (relDiff <= 0.3 && relDiff > 0.01)
+        return true;
+    // For sums: response number is between min-sum and max-plausible-sum
+    if (op === 'sum') {
+        const maxPlausible = correct * 1.5;
+        const minPlausible = correct * 0.5;
+        if (respNum >= minPlausible && respNum <= maxPlausible && respNum !== correct)
+            return true;
+    }
+    return false;
+}
+/**
+ * Match an aggregation claim against the computed correct value.
+ */
+function matchAggregation(claimedValue, computedValue, op) {
+    const tolerance = op === 'avg' ? 0.1 : 0.01;
+    const diff = Math.abs(claimedValue - computedValue);
+    const relDiff = computedValue !== 0 ? diff / Math.abs(computedValue) : diff;
+    if (relDiff <= tolerance || diff < 0.5) {
+        return {
+            matched: true,
+            explanation: `Aggregation (${op}) claim ${claimedValue} matches computed value ${computedValue}.`,
+        };
+    }
+    return {
+        matched: false,
+        explanation: `Aggregation error: response says ${claimedValue} but ${op}(${computedValue}) is the correct value. Off by ${diff.toFixed(2)} (${(relDiff * 100).toFixed(1)}%).`,
+    };
+}
+// =========================================================================
+// L2 — RANGE Matching (min/max, salary bands, thresholds)
+// =========================================================================
+/** Patterns for paired min/max fields. */
+const RANGE_MIN_PATTERNS = [/^min/i, /min$/i, /_min_/i, /minimum/i, /lower/i, /from/i, /start/i];
+const RANGE_MAX_PATTERNS = [/^max/i, /max$/i, /_max_/i, /maximum/i, /upper/i, /to$/i, /end$/i, /limit/i];
+/**
+ * Walk tool outputs and find paired min/max numeric fields.
+ * Detects: salary_min/salary_max, min_hours/max_hours, price_from/price_to, etc.
+ */
+function extractRangeFields(trace) {
+    const steps = Trace_1.TraceUtils.getToolOutputSteps(trace);
+    const numericFields = new Map();
+    for (const step of steps) {
+        for (const to of step.toolOutputs ?? []) {
+            collectNumericFields(to.output, step.stepId, '', numericFields);
+        }
+    }
+    // Pair min/max fields by root name
+    const ranges = [];
+    const processed = new Set();
+    for (const [path, entries] of numericFields) {
+        if (processed.has(path))
+            continue;
+        const lastKey = (path.split('.').pop() ?? path).toLowerCase();
+        const isMin = RANGE_MIN_PATTERNS.some((p) => p.test(lastKey));
+        const isMax = RANGE_MAX_PATTERNS.some((p) => p.test(lastKey));
+        if (!isMin && !isMax)
+            continue;
+        // Find the counterpart
+        const rootName = lastKey
+            .replace(/^min_?|_?min$|minimum|lower|^from_?|_?from$|^start_?|_?start$/gi, '')
+            .replace(/^max_?|_?max$|maximum|upper|^to_?|_?to$|^end_?|_?end$|^limit_?|_?limit$/gi, '')
+            .replace(/^_|_$/g, '') || lastKey;
+        for (const [otherPath, otherEntries] of numericFields) {
+            if (otherPath === path || processed.has(otherPath))
+                continue;
+            const otherLastKey = (otherPath.split('.').pop() ?? otherPath).toLowerCase();
+            const otherIsMin = RANGE_MIN_PATTERNS.some((p) => p.test(otherLastKey));
+            const otherIsMax = RANGE_MAX_PATTERNS.some((p) => p.test(otherLastKey));
+            if ((isMin && !otherIsMax) || (isMax && !otherIsMin))
+                continue;
+            // Check if they share a root name
+            const otherRootName = otherLastKey
+                .replace(/^min_?|_?min$|minimum|lower|^from_?|_?from$|^start_?|_?start$/gi, '')
+                .replace(/^max_?|_?max$|maximum|upper|^to_?|_?to$|^end_?|_?end$|^limit_?|_?limit$/gi, '')
+                .replace(/^_|_$/g, '') || otherLastKey;
+            if (rootName === otherRootName || (rootName === '' && otherRootName === '')) {
+                const minVal = isMin ? entries[0].value : otherEntries[0].value;
+                const maxVal = isMax ? entries[0].value : otherEntries[0].value;
+                if (minVal <= maxVal) {
+                    ranges.push({
+                        rootPath: rootName || path.replace(/\.?[^.]+$/, '') || 'range',
+                        min: minVal,
+                        max: maxVal,
+                        stepId: entries[0].stepId,
+                    });
+                    processed.add(path);
+                    processed.add(otherPath);
+                }
+            }
+        }
+    }
+    return ranges;
+}
+function collectNumericFields(value, stepId, path, out, depth = 0) {
+    if (depth > MAX_WALK_DEPTH)
+        return;
+    if (value === null || value === undefined)
+        return;
+    if (typeof value === 'number' && path && !Number.isNaN(value)) {
+        const entries = out.get(path) ?? [];
+        entries.push({ fieldName: path, value, stepId });
+        out.set(path, entries);
+    }
+    else if (Array.isArray(value)) {
+        value.forEach((item, i) => collectNumericFields(item, stepId, path ? `${path}[${i}]` : `[${i}]`, out, depth + 1));
+    }
+    else if (typeof value === 'object') {
+        for (const [k, v] of Object.entries(value)) {
+            collectNumericFields(v, stepId, path ? `${path}.${k}` : k, out, depth + 1);
+        }
+    }
+}
+/** Words in response that suggest a range is being described. */
+const RANGE_KEYWORDS = [
+    /\b(between|od|od\s+\d|izme[đd]u)\b/i,
+    /\b(up to|do|maksimalno|najvi[šs]e)\b/i,
+    /\b(at least|najmanje|minimum|minimum)\b/i,
+    /\b(range|raspon|opseg)\b/i,
+];
+/**
+ * Extract range claims: detect when response describes a min/max range from tool output.
+ */
+function extractRangeClaims(trace, responseText, sourceStepId) {
+    if (!responseText || !trace)
+        return [];
+    const ranges = extractRangeFields(trace);
+    if (ranges.length === 0)
+        return [];
+    const claims = [];
+    const responseLower = responseText.toLowerCase();
+    const responseNumbers = extractNumbersFromResponse(responseText);
+    const source = {
+        stepId: sourceStepId ?? 'final_response',
+        role: 'final_response',
+        rawText: responseText,
+    };
+    // Check if response contains range-like language
+    const hasRangeLanguage = RANGE_KEYWORDS.some((p) => p.test(responseLower));
+    if (!hasRangeLanguage && responseNumbers.length < 2)
+        return [];
+    for (const range of ranges) {
+        // Find numbers in response that could be min or max of this range
+        for (const num of responseNumbers) {
+            // Check if this number is close to the min or max
+            const isNearMin = Math.abs(num - range.min) / (Math.abs(range.min) || 1) <= 0.01 || num === range.min;
+            const isNearMax = Math.abs(num - range.max) / (Math.abs(range.max) || 1) <= 0.01 || num === range.max;
+            if (isNearMin || isNearMax) {
+                claims.push({
+                    claimId: (0, crypto_1.randomUUID)(),
+                    type: 'range',
+                    value: num,
+                    rawText: String(num),
+                    source,
+                    fieldName: range.rootPath,
+                    sourceFieldValue: { min: range.min, max: range.max },
+                });
+            }
+            else {
+                // Number in response doesn't match either endpoint — check if it's a plausible mistake
+                const isInRange = num >= range.min && num <= range.max;
+                const isNear = num >= range.min * 0.7 && num <= range.max * 1.3;
+                if (isNear && !isInRange) {
+                    // Number is close to range but outside bounds — flaggable mismatch
+                    claims.push({
+                        claimId: (0, crypto_1.randomUUID)(),
+                        type: 'range',
+                        value: num,
+                        rawText: String(num),
+                        source,
+                        fieldName: range.rootPath,
+                        sourceFieldValue: { min: range.min, max: range.max },
+                    });
+                }
+            }
+        }
+    }
+    return deduplicateClaims(claims);
+}
+/**
+ * Match a range claim: verify claimed number against source min/max.
+ */
+function matchRange(claimedValue, sourceValue) {
+    if (typeof sourceValue !== 'object' || sourceValue === null) {
+        return { matched: false, explanation: 'Source value is not a range object.' };
+    }
+    const range = sourceValue;
+    if (typeof range.min !== 'number' || typeof range.max !== 'number') {
+        return { matched: false, explanation: 'Source range missing min or max.' };
+    }
+    // Exact match to either endpoint
+    if (claimedValue === range.min || claimedValue === range.max) {
+        return {
+            matched: true,
+            explanation: `Range claim ${claimedValue} matches endpoint [${range.min}, ${range.max}].`,
+        };
+    }
+    // Close to an endpoint (within 1%)
+    const minDiff = Math.abs(claimedValue - range.min) / (Math.abs(range.min) || 1);
+    const maxDiff = Math.abs(claimedValue - range.max) / (Math.abs(range.max) || 1);
+    if (minDiff <= 0.01 || maxDiff <= 0.01) {
+        return {
+            matched: true,
+            explanation: `Range claim ${claimedValue} approximately matches endpoint [${range.min}, ${range.max}].`,
+        };
+    }
+    // Within the range (not exactly an endpoint, but valid)
+    if (claimedValue >= range.min && claimedValue <= range.max) {
+        return {
+            matched: true,
+            explanation: `Range claim ${claimedValue} is within bounds [${range.min}, ${range.max}].`,
+        };
+    }
+    return {
+        matched: false,
+        explanation: `Range mismatch: response says ${claimedValue} but source range is [${range.min}, ${range.max}].`,
+    };
+}
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+/** Find a synonym from the list that appears as a word boundary match in text. */
+function findSynonymInText(textLower, synonyms) {
+    for (const syn of synonyms) {
+        // Multi-word synonyms: "on leave", "na čekanju"
+        if (syn.includes(' ')) {
+            if (textLower.includes(syn.toLowerCase()))
+                return syn;
+        }
+        else if (AMBIGUOUS_SHORT_WORDS.has(syn.toLowerCase())) {
+            // Ambiguous short words like "da", "ne" — match when:
+            // 1. Entire response is just the word, OR
+            // 2. Response starts with the word + punctuation ("da, tačno"), OR
+            // 3. Response starts with the word + space and is short (<80 chars),
+            //    indicating an affirmative/negative answer, not a conjunction.
+            const trimmed = textLower.trim();
+            const synLow = syn.toLowerCase();
+            if (trimmed === synLow ||
+                trimmed.startsWith(synLow + ',') ||
+                trimmed.startsWith(synLow + '.') ||
+                trimmed.startsWith(synLow + '!') ||
+                trimmed.startsWith(synLow + ' -') ||
+                trimmed.startsWith(synLow + ' –') ||
+                (trimmed.startsWith(synLow + ' ') && trimmed.length < 80)) {
+                return syn;
+            }
+        }
+        else {
+            // Single word — use word boundary for ASCII, includes() for non-ASCII
+            // (JS \b only works for [a-zA-Z0-9_], not Cyrillic/CJK/Arabic/etc.)
+            const synLow = syn.toLowerCase();
+            if (/^[\x20-\x7e]+$/.test(synLow)) {
+                const re = new RegExp(`\\b${escapeRegex(syn)}\\b`, 'i');
+                if (re.test(textLower))
+                    return syn;
+            }
+            else {
+                if (textLower.includes(synLow))
+                    return syn;
+            }
+        }
+    }
+    return null;
+}
+/** Find if response contains a DIFFERENT enum value from the same domain. */
+function findContradiction(responseLower, sourceCanonical) {
+    // Only check semantically opposed values, not ALL enum translations
+    const opposites = ENUM_OPPOSITES[sourceCanonical];
+    if (!opposites)
+        return null;
+    for (const oppCanonical of opposites) {
+        const synonyms = ENUM_TRANSLATIONS[oppCanonical];
+        if (!synonyms)
+            continue;
+        for (const syn of synonyms) {
+            // Skip ambiguous short words in contradiction detection
+            if (AMBIGUOUS_SHORT_WORDS.has(syn.toLowerCase()))
+                continue;
+            if (syn.includes(' ')) {
+                if (responseLower.includes(syn.toLowerCase())) {
+                    return { foundCanonical: oppCanonical, foundSynonym: syn };
+                }
+            }
+            else {
+                const synLow = syn.toLowerCase();
+                if (/^[\x20-\x7e]+$/.test(synLow)) {
+                    const re = new RegExp(`\\b${escapeRegex(syn)}\\b`, 'i');
+                    if (re.test(responseLower)) {
+                        return { foundCanonical: oppCanonical, foundSynonym: syn };
+                    }
+                }
+                else {
+                    if (responseLower.includes(synLow)) {
+                        return { foundCanonical: oppCanonical, foundSynonym: syn };
+                    }
+                }
+            }
+        }
+    }
+    return null;
+}
+function escapeRegex(str) {
+    return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+/** Remove duplicate claims (same fieldName + same value). */
+/**
+ * Derive a metric name from a JSON field path.
+ * "employees[0].late_count" → "late_count", "overtime_hours" → "overtime_hours"
+ */
+function deriveMetric(fieldName) {
+    if (!fieldName)
+        return undefined;
+    const last = fieldName.split('.').pop() ?? fieldName;
+    const cleaned = last.replace(/\[\d+\]$/g, '');
+    return cleaned || undefined;
+}
+function deduplicateClaims(claims) {
+    const seen = new Set();
+    return claims.filter((c) => {
+        const key = `${c.fieldName}::${c.value}`;
+        if (seen.has(key))
+            return false;
+        seen.add(key);
+        // Populate metric from fieldName if not already set
+        if (!c.metric && c.fieldName) {
+            c.metric = deriveMetric(c.fieldName);
+        }
+        return true;
+    });
+}
+//# sourceMappingURL=index.js.map