noteconnection 1.6.8 → 1.8.0

package/dist/src/learning/ragContextPack.js

@@ -0,0 +1,257 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_RAG_CONTEXT_BUDGET = void 0;
+exports.normalizeRagContextBudget = normalizeRagContextBudget;
+exports.estimateRagTokenCount = estimateRagTokenCount;
+exports.buildRagContextPack = buildRagContextPack;
+const crypto_1 = require("crypto");
+exports.DEFAULT_RAG_CONTEXT_BUDGET = {
+    maxFragments: 16,
+    maxCharsPerFragment: 1600,
+    maxTotalChars: 6400,
+};
+const ROLE_PRIORITY = {
+    direct_support: 0,
+    conflict: 1,
+    graph_neighbor_support: 2,
+    parent_context: 3,
+    adjacent_context: 4,
+    background: 5,
+};
+function normalizeRagContextBudget(input) {
+    const numberOrDefault = (value, fallback, min, max) => {
+        const numeric = Number(value);
+        if (!Number.isFinite(numeric)) {
+            return fallback;
+        }
+        return Math.floor(Math.max(min, Math.min(max, numeric)));
+    };
+    return {
+        maxFragments: numberOrDefault(input?.maxFragments, exports.DEFAULT_RAG_CONTEXT_BUDGET.maxFragments, 1, 200),
+        maxCharsPerFragment: numberOrDefault(input?.maxCharsPerFragment, exports.DEFAULT_RAG_CONTEXT_BUDGET.maxCharsPerFragment, 80, 20000),
+        maxTotalChars: numberOrDefault(input?.maxTotalChars, exports.DEFAULT_RAG_CONTEXT_BUDGET.maxTotalChars, 120, 100000),
+    };
+}
+function estimateRagTokenCount(text) {
+    const normalized = String(text || '').trim();
+    if (!normalized) {
+        return 0;
+    }
+    return Math.max(1, Math.ceil(normalized.length / 4));
+}
+function truncateMiddle(text, maxChars) {
+    const source = String(text || '');
+    if (source.length <= maxChars) {
+        return { text: source, truncated: false };
+    }
+    if (maxChars <= 16) {
+        return { text: source.slice(0, maxChars), truncated: true };
+    }
+    const marker = '\n[...]\n';
+    const available = Math.max(0, maxChars - marker.length);
+    const headLength = Math.ceil(available * 0.6);
+    const tailLength = Math.floor(available * 0.4);
+    return {
+        text: `${source.slice(0, headLength).trimEnd()}${marker}${source.slice(source.length - tailLength).trimStart()}`,
+        truncated: true,
+    };
+}
+function withBudgetedText(fragment, maxChars, reason) {
+    const truncated = truncateMiddle(fragment.text, maxChars);
+    const text = truncated.text;
+    return {
+        ...fragment,
+        text,
+        charCount: text.length,
+        tokenEstimate: estimateRagTokenCount(text),
+        truncated: fragment.truncated || truncated.truncated,
+        truncationReason: truncated.truncated ? reason : fragment.truncationReason,
+    };
+}
+function rolePriority(fragment) {
+    return ROLE_PRIORITY[fragment.role] ?? ROLE_PRIORITY.background;
+}
+function sortFragmentsForBudget(fragments) {
+    return fragments
+        .map((fragment, index) => ({ fragment, index }))
+        .sort((a, b) => {
+        const priorityDelta = rolePriority(a.fragment) - rolePriority(b.fragment);
+        if (priorityDelta !== 0) {
+            return priorityDelta;
+        }
+        const scoreDelta = Number(b.fragment.score || 0) - Number(a.fragment.score || 0);
+        if (Math.abs(scoreDelta) > 0.0001) {
+            return scoreDelta;
+        }
+        return a.index - b.index;
+    })
+        .map((entry) => entry.fragment);
+}
+function applyContextBudget(fragments, budget, decisions) {
+    const selected = [];
+    let usedChars = 0;
+    sortFragmentsForBudget(fragments).forEach((fragment) => {
+        if (selected.length >= budget.maxFragments) {
+            decisions.push({
+                documentId: fragment.documentId,
+                sourcePath: fragment.sourcePath,
+                sourceBoundary: fragment.sourceBoundary,
+                status: 'fragment_dropped',
+                reason: 'max_fragments_exceeded',
+            });
+            return;
+        }
+        let candidate = withBudgetedText(fragment, budget.maxCharsPerFragment, 'max_chars_per_fragment_exceeded');
+        const remainingChars = budget.maxTotalChars - usedChars;
+        if (remainingChars <= 0) {
+            decisions.push({
+                documentId: fragment.documentId,
+                sourcePath: fragment.sourcePath,
+                sourceBoundary: fragment.sourceBoundary,
+                status: 'fragment_dropped',
+                reason: 'max_total_chars_exceeded',
+            });
+            return;
+        }
+        if (candidate.charCount > remainingChars) {
+            if (remainingChars < 80 && candidate.role !== 'direct_support') {
+                decisions.push({
+                    documentId: fragment.documentId,
+                    sourcePath: fragment.sourcePath,
+                    sourceBoundary: fragment.sourceBoundary,
+                    status: 'fragment_dropped',
+                    reason: 'remaining_context_budget_too_small',
+                });
+                return;
+            }
+            candidate = withBudgetedText(candidate, remainingChars, 'max_total_chars_exceeded');
+        }
+        selected.push(candidate);
+        usedChars += candidate.charCount;
+        decisions.push({
+            documentId: candidate.documentId,
+            sourcePath: candidate.sourcePath,
+            sourceBoundary: candidate.sourceBoundary,
+            status: candidate.truncated ? 'fragment_truncated' : 'fragment_included',
+            reason: candidate.truncationReason,
+        });
+    });
+    return selected;
+}
+function resolveSourceBoundary(requestedBoundary, fragments) {
+    if (requestedBoundary) {
+        return requestedBoundary;
+    }
+    return fragments.some((fragment) => fragment.sourceBoundary === 'full_document')
+        ? 'full_document'
+        : 'direct_span_only';
+}
+function annotateReadDecisions(decisions, fragments) {
+    const fragmentCountsByDocument = fragments.reduce((counts, fragment) => {
+        const previous = counts.get(fragment.documentId) || 0;
+        counts.set(fragment.documentId, previous + 1);
+        return counts;
+    }, new Map());
+    decisions.forEach((decision) => {
+        if (decision.status === 'read') {
+            decision.fragmentsSelected = fragmentCountsByDocument.get(decision.documentId) || 0;
+        }
+    });
+}
+function sortedStrings(values) {
+    return normalizedStrings(values).sort();
+}
+function normalizedStrings(values) {
+    return (Array.isArray(values) ? values : [])
+        .map((value) => String(value || '').trim())
+        .filter(Boolean);
+}
+function buildRagContextReplayId(params) {
+    const payload = {
+        query: params.query,
+        sourceBoundary: params.sourceBoundary,
+        budget: params.budget,
+        totalCharCount: params.totalCharCount,
+        tokenEstimate: params.tokenEstimate,
+        fragments: params.fragments
+            .map((fragment) => ({
+            fragmentId: fragment.fragmentId,
+            role: fragment.role,
+            documentId: fragment.documentId,
+            sourcePath: fragment.sourcePath,
+            atomId: fragment.atomId || '',
+            title: fragment.title || '',
+            headingPath: normalizedStrings(fragment.headingPath),
+            citationIds: sortedStrings(fragment.citationIds),
+            relationEdgeIds: sortedStrings(fragment.relationEdgeIds),
+            sourceBoundary: fragment.sourceBoundary,
+            startOffset: fragment.startOffset ?? null,
+            endOffset: fragment.endOffset ?? null,
+            startLine: fragment.startLine ?? null,
+            endLine: fragment.endLine ?? null,
+            truncated: fragment.truncated,
+            truncationReason: fragment.truncationReason || '',
+            text: fragment.text,
+        }))
+            .sort((left, right) => [
+            left.role.localeCompare(right.role),
+            left.documentId.localeCompare(right.documentId),
+            left.fragmentId.localeCompare(right.fragmentId),
+            left.text.localeCompare(right.text),
+        ].find((delta) => delta !== 0) || 0),
+        sourceDecisions: params.sourceDecisions
+            .map((decision) => ({
+            documentId: decision.documentId,
+            sourcePath: decision.sourcePath,
+            sourceBoundary: decision.sourceBoundary,
+            status: decision.status,
+            reason: decision.reason || '',
+            charsRead: decision.charsRead ?? null,
+            fragmentsSelected: decision.fragmentsSelected ?? null,
+        }))
+            .sort((left, right) => [
+            left.documentId.localeCompare(right.documentId),
+            left.sourcePath.localeCompare(right.sourcePath),
+            left.sourceBoundary.localeCompare(right.sourceBoundary),
+            left.status.localeCompare(right.status),
+            left.reason.localeCompare(right.reason),
+        ].find((delta) => delta !== 0) || 0),
+    };
+    const digest = (0, crypto_1.createHash)('sha256')
+        .update(JSON.stringify(payload))
+        .digest('hex')
+        .slice(0, 16);
+    return `ragctx_${digest}`;
+}
+function buildRagContextPack(params) {
+    const budget = normalizeRagContextBudget(params.budget);
+    const decisions = Array.isArray(params.sourceDecisions)
+        ? params.sourceDecisions.map((decision) => ({ ...decision }))
+        : [];
+    const fragments = Array.isArray(params.fragments) ? params.fragments.filter(Boolean) : [];
+    const selectedFragments = applyContextBudget(fragments, budget, decisions);
+    annotateReadDecisions(decisions, selectedFragments);
+    const totalCharCount = selectedFragments.reduce((sum, fragment) => sum + fragment.charCount, 0);
+    const tokenEstimate = selectedFragments.reduce((sum, fragment) => sum + fragment.tokenEstimate, 0);
+    const query = String(params.query || '');
+    const sourceBoundary = resolveSourceBoundary(params.sourceBoundary, selectedFragments);
+    return {
+        replayId: buildRagContextReplayId({
+            query,
+            sourceBoundary,
+            budget,
+            fragments: selectedFragments,
+            sourceDecisions: decisions,
+            totalCharCount,
+            tokenEstimate,
+        }),
+        query,
+        generatedAt: String(params.generatedAt || new Date().toISOString()),
+        sourceBoundary,
+        budget,
+        fragments: selectedFragments,
+        sourceDecisions: decisions,
+        totalCharCount,
+        tokenEstimate,
+    };
+}

package/dist/src/learning/ragContextPack.test.js

@@ -0,0 +1,160 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const ragContextPack_1 = require("./ragContextPack");
+function makeFragment(overrides = {}) {
+    const text = overrides.text || 'A water glass is a transparent drinking vessel that contains water.';
+    return {
+        fragmentId: overrides.fragmentId || `fragment_${overrides.role || 'direct_support'}`,
+        role: overrides.role || 'direct_support',
+        text,
+        atomId: overrides.atomId || 'atom_water_glass',
+        documentId: overrides.documentId || 'doc_water_glass',
+        sourcePath: overrides.sourcePath || 'Knowledge_Base/test/water-glass.md',
+        title: overrides.title || 'Water Glass',
+        headingPath: Array.isArray(overrides.headingPath) ? overrides.headingPath : ['Water Glass'],
+        startOffset: overrides.startOffset,
+        endOffset: overrides.endOffset,
+        startLine: overrides.startLine,
+        endLine: overrides.endLine,
+        charCount: text.length,
+        tokenEstimate: Math.ceil(text.length / 4),
+        truncated: overrides.truncated === true,
+        truncationReason: overrides.truncationReason,
+        citationIds: Array.isArray(overrides.citationIds) ? overrides.citationIds : ['evidence_water_glass'],
+        relationEdgeIds: Array.isArray(overrides.relationEdgeIds) ? overrides.relationEdgeIds : [],
+        score: Number.isFinite(overrides.score) ? Number(overrides.score) : 0.8,
+        sourceBoundary: overrides.sourceBoundary || 'direct_span_only',
+    };
+}
+describe('buildRagContextPack', () => {
+    test('generates a stable replay id from the selected evidence payload', () => {
+        const direct = makeFragment({
+            fragmentId: 'direct_water_glass',
+            role: 'direct_support',
+            text: 'Direct definition of water glass.',
+            score: 0.72,
+        });
+        const parent = makeFragment({
+            fragmentId: 'parent_water_glass',
+            role: 'parent_context',
+            text: 'Parent section explains the vessel boundary and optical qualifier.',
+            sourceBoundary: 'full_document',
+            score: 0.61,
+        });
+        const baseParams = {
+            query: 'what is water glass?',
+            sourceDecisions: [
+                {
+                    documentId: 'doc_water_glass',
+                    sourcePath: 'Knowledge_Base/test/water-glass.md',
+                    sourceBoundary: 'full_document',
+                    status: 'read',
+                    charsRead: 4096,
+                },
+            ],
+            budget: {
+                maxFragments: 4,
+                maxCharsPerFragment: 400,
+                maxTotalChars: 900,
+            },
+            generatedAt: '2026-07-05T00:00:00.000Z',
+        };
+        const firstPack = (0, ragContextPack_1.buildRagContextPack)({
+            ...baseParams,
+            fragments: [parent, direct],
+        });
+        const secondPack = (0, ragContextPack_1.buildRagContextPack)({
+            ...baseParams,
+            fragments: [direct, parent],
+        });
+        const changedPack = (0, ragContextPack_1.buildRagContextPack)({
+            ...baseParams,
+            fragments: [
+                direct,
+                {
+                    ...parent,
+                    text: 'Parent section now carries a different qualifier.',
+                    charCount: 'Parent section now carries a different qualifier.'.length,
+                },
+            ],
+        });
+        expect(firstPack.replayId).toMatch(/^ragctx_[a-f0-9]{16}$/);
+        expect(secondPack.replayId).toBe(firstPack.replayId);
+        expect(changedPack.replayId).not.toBe(firstPack.replayId);
+    });
+    test('middle-truncates oversized fragments while preserving the opening and terminal qualifier', () => {
+        const longText = [
+            'Opening definition: a water glass is a transparent vessel.',
+            'Middle detail '.repeat(30),
+            'Terminal qualifier: this claim only covers the scoped note.',
+        ].join('\n');
+        const pack = (0, ragContextPack_1.buildRagContextPack)({
+            query: 'what is water glass?',
+            fragments: [
+                makeFragment({
+                    role: 'parent_context',
+                    text: longText,
+                    sourceBoundary: 'full_document',
+                }),
+            ],
+            sourceDecisions: [],
+            budget: {
+                maxFragments: 3,
+                maxCharsPerFragment: 180,
+                maxTotalChars: 220,
+            },
+            generatedAt: '2026-07-05T00:00:00.000Z',
+        });
+        expect(pack.fragments).toHaveLength(1);
+        expect(pack.fragments[0].truncated).toBe(true);
+        expect(pack.fragments[0].text).toContain('Opening definition');
+        expect(pack.fragments[0].text).toContain('Terminal qualifier');
+        expect(pack.fragments[0].text).toContain('[...]');
+        expect(pack.sourceDecisions).toEqual(expect.arrayContaining([
+            expect.objectContaining({
+                status: 'fragment_truncated',
+                reason: 'max_chars_per_fragment_exceeded',
+            }),
+        ]));
+    });
+    test('uses role priority so weak background cannot displace direct or graph evidence', () => {
+        const pack = (0, ragContextPack_1.buildRagContextPack)({
+            query: 'what is water glass?',
+            fragments: [
+                makeFragment({
+                    fragmentId: 'background_1',
+                    role: 'background',
+                    text: 'Background note with weak topical overlap.',
+                    score: 0.95,
+                }),
+                makeFragment({
+                    fragmentId: 'direct_1',
+                    role: 'direct_support',
+                    text: 'Direct definition of water glass.',
+                    score: 0.7,
+                }),
+                makeFragment({
+                    fragmentId: 'graph_1',
+                    role: 'graph_neighbor_support',
+                    text: 'Graph neighbor evidence about vessel boundary.',
+                    score: 0.6,
+                    sourceBoundary: 'full_document',
+                }),
+            ],
+            sourceDecisions: [],
+            budget: {
+                maxFragments: 2,
+                maxCharsPerFragment: 200,
+                maxTotalChars: 400,
+            },
+        });
+        expect(pack.fragments.map((fragment) => fragment.fragmentId)).toEqual(['direct_1', 'graph_1']);
+        expect(pack.sourceDecisions).toEqual(expect.arrayContaining([
+            expect.objectContaining({
+                status: 'fragment_dropped',
+                reason: 'max_fragments_exceeded',
+                documentId: 'doc_water_glass',
+            }),
+        ]));
+    });
+});

package/dist/src/learning/ragPublicText.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.naturalizeRagPublicEvidenceClause = naturalizeRagPublicEvidenceClause;
+exports.shouldRejectCompareProcedureEvidenceClause = shouldRejectCompareProcedureEvidenceClause;
+function normalizeWhitespace(value) {
+    return String(value || '').replace(/\s+/g, ' ').trim();
+}
+const LEADING_SOURCE_LABEL_PATTERN = /^(?:prerequisites?|preconditions?|requirements?|background|context|mechanism|reasoning boundary|downstream checks?|downstream consequences?|failure modes?|mitigation(?: neighbor)?|graph caveat|caveat|evidence|summary|note)\s*[:\uFF1A-]\s*/iu;
+const PRESERVED_LEADING_LABEL_PATTERN = /^(?:step|phase|stage|section)\s*\d+\s*[:\uFF1A-]/iu;
+function naturalizeRagPublicEvidenceClause(value) {
+    let normalized = normalizeWhitespace(value);
+    if (!normalized || PRESERVED_LEADING_LABEL_PATTERN.test(normalized)) {
+        return normalized;
+    }
+    for (let pass = 0; pass < 3; pass += 1) {
+        const next = normalizeWhitespace(normalized.replace(LEADING_SOURCE_LABEL_PATTERN, ''));
+        if (!next || next === normalized) {
+            break;
+        }
+        normalized = next;
+        if (PRESERVED_LEADING_LABEL_PATTERN.test(normalized)) {
+            break;
+        }
+    }
+    return normalized;
+}
+function shouldRejectCompareProcedureEvidenceClause(value, query) {
+    const normalizedClause = normalizeWhitespace(value).toLowerCase();
+    const normalizedQuery = normalizeWhitespace(query).toLowerCase();
+    if (!normalizedClause) {
+        return false;
+    }
+    if (/\b(?:procedure|procedural|workflow|runbook|steps?|step\s*\d+|sequence)\b/u.test(normalizedQuery)) {
+        return false;
+    }
+    return /\b(?:procedure|workflow|runbook|steps?|step\s*\d+)\b/u.test(normalizedClause)
+        || /\bprocedural\b.{0,80}\bsequence\b/u.test(normalizedClause);
+}

package/dist/src/learning/ragSufficiencyJudge.js

@@ -0,0 +1,161 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.reviewRagContextSufficiency = reviewRagContextSufficiency;
+function clampUnit(value) {
+    if (!Number.isFinite(value)) {
+        return 0;
+    }
+    return Number(Math.max(0, Math.min(1, value)).toFixed(4));
+}
+function hasCitation(fragment) {
+    return Array.isArray(fragment.citationIds) && fragment.citationIds.some((citationId) => String(citationId || '').trim());
+}
+function textHasSubstance(fragment) {
+    return String(fragment.text || '').trim().length >= 24;
+}
+function hasDirectSupport(fragments) {
+    return fragments.some((fragment) => fragment.role === 'direct_support' && hasCitation(fragment) && textHasSubstance(fragment));
+}
+function hasDocumentAugmentation(fragments) {
+    return fragments.some((fragment) => ((fragment.role === 'parent_context' || fragment.role === 'adjacent_context')
+        && fragment.sourceBoundary === 'full_document'
+        && textHasSubstance(fragment)));
+}
+function hasGraphEvidence(fragments) {
+    return fragments.some((fragment) => fragment.role === 'graph_neighbor_support' && hasCitation(fragment) && textHasSubstance(fragment));
+}
+function hasConflictEvidence(fragments) {
+    return fragments.some((fragment) => fragment.role === 'conflict' && textHasSubstance(fragment));
+}
+function hasUnavailableGraphNeighborSourceWindow(pack) {
+    return pack.sourceDecisions.some((decision) => (decision.status === 'source_window_unavailable'
+        && String(decision.reason || '').includes('graph_neighbor_support')));
+}
+function hasBudgetViolation(pack) {
+    return pack.sourceDecisions.some((decision) => (decision.status === 'fragment_dropped'
+        && (decision.reason === 'max_total_chars_exceeded' || decision.reason === 'max_fragments_exceeded')));
+}
+function buildDeterministicReview(params) {
+    const fragments = Array.isArray(params.contextPack.fragments) ? params.contextPack.fragments : [];
+    const directSupport = hasDirectSupport(fragments);
+    const documentAugmentation = hasDocumentAugmentation(fragments);
+    const graphEvidence = hasGraphEvidence(fragments);
+    const conflictEvidence = hasConflictEvidence(fragments);
+    const graphNeighborSourceUnavailable = hasUnavailableGraphNeighborSourceWindow(params.contextPack);
+    const budgetViolation = hasBudgetViolation(params.contextPack);
+    const reasons = [];
+    if (!directSupport) {
+        reasons.push('missing_direct_support');
+    }
+    if (!documentAugmentation) {
+        reasons.push('document_augmentation_missing');
+    }
+    const graphNeighborEvidenceMissing = Boolean(params.graphContext && (!graphEvidence || graphNeighborSourceUnavailable) && ((params.graphContext.predecessorWindow?.length || 0) > 0
+        || (params.graphContext.successorWindow?.length || 0) > 0));
+    if (graphNeighborEvidenceMissing) {
+        reasons.push('graph_neighbor_evidence_missing');
+    }
+    if (conflictEvidence) {
+        reasons.push('conflict_evidence_present');
+    }
+    if (budgetViolation) {
+        reasons.push('context_budget_dropped_fragments');
+    }
+    if (!directSupport) {
+        return {
+            reviewedAt: String(params.reviewedAt || new Date().toISOString()),
+            status: 'insufficient',
+            score: 0.2,
+            reasons,
+            deterministic: true,
+            recoveryAttempted: false,
+            llmJudgeUsed: false,
+            degradationState: 'insufficient_evidence',
+        };
+    }
+    let score = 0.58;
+    if (documentAugmentation) {
+        score += 0.24;
+    }
+    if (graphEvidence) {
+        score += 0.08;
+    }
+    if (!budgetViolation) {
+        score += 0.06;
+    }
+    if (conflictEvidence) {
+        score -= 0.18;
+    }
+    score = clampUnit(score);
+    const status = score >= 0.75
+        && documentAugmentation
+        && !conflictEvidence
+        && !graphNeighborEvidenceMissing
+        ? 'sufficient'
+        : 'borderline';
+    return {
+        reviewedAt: String(params.reviewedAt || new Date().toISOString()),
+        status,
+        score,
+        reasons,
+        deterministic: true,
+        recoveryAttempted: false,
+        llmJudgeUsed: false,
+        degradationState: status === 'sufficient'
+            ? 'none'
+            : conflictEvidence
+                ? 'conflict'
+                : 'partial_coverage',
+    };
+}
+function mergeLlmJudgeReview(deterministicReview, judgeReview) {
+    if (!judgeReview) {
+        return deterministicReview;
+    }
+    const nextStatus = judgeReview.status === 'sufficient'
+        || judgeReview.status === 'borderline'
+        || judgeReview.status === 'insufficient'
+        ? judgeReview.status
+        : deterministicReview.status;
+    const nextScore = Number.isFinite(judgeReview.score)
+        ? clampUnit(Number(judgeReview.score))
+        : deterministicReview.score;
+    const nextReasons = Array.isArray(judgeReview.reasons) && judgeReview.reasons.length > 0
+        ? judgeReview.reasons.map((reason) => String(reason || '').trim()).filter(Boolean)
+        : deterministicReview.reasons;
+    return {
+        ...deterministicReview,
+        ...judgeReview,
+        status: nextStatus,
+        score: nextScore,
+        reasons: nextReasons,
+        deterministic: false,
+        llmJudgeUsed: true,
+    };
+}
+async function reviewRagContextSufficiency(params) {
+    const deterministicReview = buildDeterministicReview(params);
+    if (deterministicReview.status !== 'borderline'
+        || params.allowLlmJudge !== true
+        || typeof params.llmJudge !== 'function') {
+        return deterministicReview;
+    }
+    try {
+        const judgeReview = await params.llmJudge({
+            query: params.query,
+            contextPack: params.contextPack,
+            graphContext: params.graphContext,
+        });
+        return mergeLlmJudgeReview(deterministicReview, judgeReview);
+    }
+    catch (error) {
+        return {
+            ...deterministicReview,
+            reasons: [
+                ...deterministicReview.reasons,
+                `llm_judge_failed:${String(error?.message || error || 'unknown')}`,
+            ],
+            llmJudgeUsed: false,
+        };
+    }
+}