@useody/detectors 0.0.1

package/dist/contradiction-helpers.js

@@ -0,0 +1,163 @@
+const NUMBER_UNIT_PATTERN = /\$?(\d[\d,]*(?:\.\d+)?)\s*\+?\s*(?:per\s+)?(requests?|min|minutes?|hour|hours?|day|days?|month|months?|week|weeks?|\/\w+|calls?|users?|people|persons?|employees?|members?|%|percent|gpus?|nodes?|cores?|GBs?|instances?|seconds?|tokens?)/gi;
+const STOPWORDS = new Set([
+    'a', 'an', 'the', 'is', 'are', 'was', 'were', 'be', 'been', 'being',
+    'have', 'has', 'had', 'do', 'does', 'did', 'will', 'would', 'could',
+    'should', 'may', 'might', 'can', 'in', 'on', 'at', 'to', 'for', 'of',
+    'and', 'or', 'but', 'not', 'with', 'from', 'by', 'into', 'it', 'its',
+    'this', 'that', 'we', 'our', 'all', 'use', 'uses', 'used', 'than',
+]);
+const CONTEXT_STOPWORDS = new Set([
+    'per', 'hour', 'hours', 'min', 'minute', 'minutes',
+    'day', 'days', 'week', 'weeks', 'month', 'months', 'second', 'seconds',
+]);
+/** Extract number+unit pairs from text. */
+export function extractNumbers(text) {
+    const results = [];
+    const re = new RegExp(NUMBER_UNIT_PATTERN.source, NUMBER_UNIT_PATTERN.flags);
+    let m;
+    while ((m = re.exec(text)) !== null) {
+        const value = parseFloat(m[1].replace(/,/g, ''));
+        const unit = m[2].toLowerCase().replace(/s$/, '');
+        results.push({ value, unit, raw: m[0], index: m.index });
+    }
+    return results;
+}
+/** Normalize unit names for comparison. */
+export function normalizeUnit(u) {
+    const map = {
+        min: 'minute', minute: 'minute',
+        hour: 'hour', day: 'day', week: 'week', month: 'month',
+        request: 'request', call: 'call',
+        user: 'user', people: 'person', person: 'person',
+        employee: 'person', member: 'person',
+    };
+    return map[u] ?? u;
+}
+/** Get raw text from a node for content-based heuristics. */
+export function getNodeText(node) {
+    const raw = node.content.raw ?? '';
+    const facts = (node.content.facts ?? []).join(' ');
+    return `${node.title} ${node.content.summary} ${facts} ${raw}`;
+}
+/** Extract the sentence containing the match at matchIndex. */
+export function extractSentence(text, matchIndex) {
+    let start = matchIndex;
+    while (start > 0 && !/[.!?\n]/.test(text[start - 1]))
+        start--;
+    let end = matchIndex;
+    while (end < text.length && !/[.!?\n]/.test(text[end]))
+        end++;
+    return text.slice(start, end).trim();
+}
+/** Capitalize the first letter of a string. */
+export function capitalizeFirst(s) {
+    return s.charAt(0).toUpperCase() + s.slice(1);
+}
+/** Extract topic keywords from a node's raw content only. */
+export function rawKeywords(node) {
+    const text = node.content.raw ?? '';
+    return new Set(text.toLowerCase().split(/\W+/)
+        .filter((w) => w.length > 2 && !STOPWORDS.has(w) && !CONTEXT_STOPWORDS.has(w)));
+}
+/** Canonical pair key for deduplication. */
+export function pairKey(id1, id2) {
+    return id1 < id2 ? `${id1}:${id2}` : `${id2}:${id1}`;
+}
+/** Return true if two nodes plausibly discuss the same topic. */
+export function areSameTopic(a, b) {
+    const srcA = a.content.source?.sourceId ?? '';
+    const srcB = b.content.source?.sourceId ?? '';
+    if (srcA && srcB && srcA === srcB)
+        return true;
+    const wA = new Set(a.title.toLowerCase().split(/\W+/).filter((w) => w.length > 3));
+    if (b.title.toLowerCase().split(/\W+/).some((w) => w.length > 3 && wA.has(w)))
+        return true;
+    const kwA = rawKeywords(a);
+    const kwB = rawKeywords(b);
+    const shared = [...kwA].filter((k) => kwB.has(k));
+    return shared.length >= 4;
+}
+/** Return true if both texts share an identical long sentence. */
+export function shareExactSentence(textA, textB) {
+    const sA = textA.split(/[.!?\n]+/).map((s) => s.trim().toLowerCase()).filter((s) => s.length > 20);
+    const sB = new Set(textB.split(/[.!?\n]+/).map((s) => s.trim().toLowerCase()).filter((s) => s.length > 20));
+    return sA.some((s) => sB.has(s));
+}
+/** Build set of entities appearing in >50% of nodes. */
+export function buildHighFreqEntities(nodes) {
+    if (nodes.length <= 4)
+        return new Set();
+    const freq = new Map();
+    for (const node of nodes) {
+        for (const ent of node.content.entities ?? []) {
+            const name = ent.name.toLowerCase();
+            freq.set(name, (freq.get(name) ?? 0) + 1);
+        }
+    }
+    const threshold = nodes.length * 0.3;
+    const result = new Set();
+    for (const [name, count] of freq) {
+        if (count > threshold)
+            result.add(name);
+    }
+    return result;
+}
+// Boolean/policy pairs: phrase A in doc 1 contradicts phrase B in doc 2.
+/** @internal */
+export const BOOLEAN_PAIRS = [
+    [/\bremote[- ]first\b/i, /\b(?:in[- ]office|office[- ](?:first|required|days?)|monday|tuesday|wednesday|thursday|friday)\b/i,
+        'remote-first', 'office requirement'],
+    [/\b(?:allowed|can)\s+(?:to\s+)?work\s+remote/i, /\bremote\s+work\s+is\s+not\s+permitted\b/i,
+        'remote work allowed', 'remote work not permitted'],
+    [/\b(?:allowed|can)\s+(?:to\s+)?work\s+remote/i, /\bmust\s+work\s+from\s+the\s+office\s+full[- ]time\b/i,
+        'remote work allowed', 'must work from office full-time'],
+    [/\bwork\s+remote(?:ly)?\b/i, /\boffice\s+full[- ]?time\b/i,
+        'remote work', 'full-time office'],
+    [/\bdeprecated\b/i, /\bcurrent(?:ly)?\s+(?:supported|active|used)\b/i,
+        'deprecated', 'current'],
+    [/\bunder\s+a\s+minute\b/i, /\ba\s+few\s+minutes\b/i,
+        'under a minute', 'a few minutes'],
+    [/\bunlimited\s+(?:vacation|pto|time\s+off)\b/i, /\b\d+\s+days?\s+(?:of\s+)?(?:paid\s+)?(?:vacation|pto|time\s+off)\b/i,
+        'unlimited vacation', 'limited vacation days'],
+];
+/** Words near enabled/disabled or required/optional that indicate a spec, not a policy. */
+export const CONFIG_CONTEXT = /\b(toggle|setting|flag|config|checkbox|option|parameter|property|attribute|button|switch|mode|state|default|value|field|prerequisite|dependency|component|install|version|package|library|sdk|module)\b/i;
+/** Detect contradictions from shared entities with different facts. */
+export function detectFactContradiction(a, b, out, highFreqEntities) {
+    const factsA = a.content.facts ?? [];
+    const factsB = b.content.facts ?? [];
+    if (factsA.length === 0 || factsB.length === 0)
+        return;
+    const entA = new Set((a.content.entities ?? []).map((e) => e.name.toLowerCase()));
+    const entB = new Set((b.content.entities ?? []).map((e) => e.name.toLowerCase()));
+    const shared = [...entA].filter((e) => entB.has(e) && !highFreqEntities.has(e));
+    const meaningful = shared.filter((e) => e.length > 3);
+    if (meaningful.length < 3)
+        return;
+    const setA = new Set(factsA.map((f) => f.toLowerCase()));
+    const setB = new Set(factsB.map((f) => f.toLowerCase()));
+    if ([...setA].every((f) => setB.has(f)))
+        return;
+    const kwA = new Set(factsA.join(' ').toLowerCase().split(/\W+/).filter((w) => w.length > 2 && !STOPWORDS.has(w)));
+    const kwB = new Set(factsB.join(' ').toLowerCase().split(/\W+/).filter((w) => w.length > 2 && !STOPWORDS.has(w)));
+    const onlyA = factsA.filter((f) => !setB.has(f.toLowerCase())).slice(0, 2);
+    const onlyB = factsB.filter((f) => !setA.has(f.toLowerCase())).slice(0, 2);
+    // Both sides must have unique facts — one-sided differences are gaps, not contradictions
+    if (onlyA.length === 0 || onlyB.length === 0)
+        return;
+    if (![...kwA].some((k) => kwB.has(k)))
+        return;
+    const quoteA = onlyA.join('; ');
+    const quoteB = onlyB.join('; ');
+    const topic = meaningful.slice(0, 3).join(', ');
+    out.push({
+        type: 'contradiction', severity: 'info', nodeIds: [a.id, b.id],
+        description: `When discussing ${topic}, "${a.title}" states: ${quoteA} — while "${b.title}" states: ${quoteB}`,
+        suggestedAction: `Review "${a.title}" and "${b.title}" for consistency.`,
+        metadata: {
+            sharedEntities: meaningful, factsA: onlyA, factsB: onlyB,
+            claimA: quoteA, claimB: quoteB, topic,
+        },
+    });
+}
+//# sourceMappingURL=contradiction-helpers.js.map

package/dist/contradictions.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Contradiction detector.
+ * Finds knowledge nodes that contradict each other via edges, LLM claim
+ * comparison, or content heuristics (fallback when no LLM is available).
+ * @module contradictions
+ */
+import type { KnowledgeNode, DetectorFn } from '@useody/platform-core';
+import { extractNumbers } from './contradiction-helpers.js';
+/** Check if two nodes are siblings (share the same parent chain prefix). */
+declare function areSiblings(a: KnowledgeNode, b: KnowledgeNode): boolean;
+/** Check if both nodes have authoritative analysis hints. */
+declare function areBothAuthoritative(a: KnowledgeNode, b: KnowledgeNode): boolean;
+/**
+ * Detect contradictions between knowledge nodes.
+ * Uses edges first, then LLM claim comparison (if available),
+ * otherwise falls back to heuristic detection.
+ */
+declare const detectContradictions: DetectorFn;
+export { detectContradictions, extractNumbers, areSiblings, areBothAuthoritative, };
+//# sourceMappingURL=contradictions.d.ts.map

package/dist/contradictions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"contradictions.d.ts","sourceRoot":"","sources":["../src/contradictions.ts"],"names":[],"mappings":"AACA;;;;;GAKG;AACH,OAAO,KAAK,EACV,aAAa,EAGb,UAAU,EAEX,MAAM,uBAAuB,CAAC;AAG/B,OAAO,EACL,cAAc,EAaf,MAAM,4BAA4B,CAAC;AAqKpC,4EAA4E;AAC5E,iBAAS,WAAW,CAAC,CAAC,EAAE,aAAa,EAAE,CAAC,EAAE,aAAa,GAAG,OAAO,CAchE;AAED,6DAA6D;AAC7D,iBAAS,oBAAoB,CAAC,CAAC,EAAE,aAAa,EAAE,CAAC,EAAE,aAAa,GAAG,OAAO,CAMzE;AA6BD;;;;GAIG;AACH,QAAA,MAAM,oBAAoB,EAAE,UAiC3B,CAAC;AAOF,OAAO,EACL,oBAAoB,EACpB,cAAc,EACd,WAAW,EACX,oBAAoB,GACrB,CAAC"}

package/dist/contradictions.js

@@ -0,0 +1,235 @@
+import { detectClaimContradictions } from './claim-comparison.js';
+import { detectClaimNliContradictions } from './claim-nli.js';
+import { extractNumbers, normalizeUnit, getNodeText, extractSentence, capitalizeFirst, rawKeywords, pairKey, areSameTopic, shareExactSentence, buildHighFreqEntities, detectFactContradiction, BOOLEAN_PAIRS, CONFIG_CONTEXT, } from './contradiction-helpers.js';
+/** Detect edge-based contradictions. */
+function detectEdgeContradictions(nodes, edges, out, seen) {
+    const contradictEdges = edges.filter((e) => e.type === 'contradicts');
+    const nodeMap = new Map(nodes.map((n) => [n.id, n]));
+    for (const edge of contradictEdges) {
+        const nodeA = nodeMap.get(edge.sourceId);
+        const nodeB = nodeMap.get(edge.targetId);
+        if (!nodeA || !nodeB)
+            continue;
+        const key = pairKey(nodeA.id, nodeB.id);
+        seen.add(key);
+        out.push({
+            type: 'contradiction',
+            severity: edge.confidence >= 0.8 ? 'critical' : 'warning',
+            nodeIds: [nodeA.id, nodeB.id],
+            description: edge.reason,
+            suggestedAction: `Resolve which is current: "${nodeA.title}" or "${nodeB.title}"`,
+        });
+    }
+}
+/** Heuristic fallback: number, boolean, and fact-based detection. */
+function detectHeuristicContradictions(nodes, out, seen) {
+    const highFreqEntities = buildHighFreqEntities(nodes);
+    const MAX_FACT_INFO = 10;
+    let factInfoCount = 0;
+    for (let i = 0; i < nodes.length; i++) {
+        for (let j = i + 1; j < nodes.length; j++) {
+            const a = nodes[i];
+            const b = nodes[j];
+            const key = pairKey(a.id, b.id);
+            if (seen.has(key))
+                continue;
+            const pairDets = [];
+            if (factInfoCount < MAX_FACT_INFO) {
+                detectFactContradiction(a, b, pairDets, highFreqEntities);
+                if (pairDets.some((d) => d.severity === 'info'))
+                    factInfoCount++;
+            }
+            if (pairDets.length === 0)
+                detectNumberContradiction(a, b, pairDets);
+            if (pairDets.length === 0)
+                detectBooleanContradiction(a, b, pairDets);
+            if (pairDets.length > 0) {
+                seen.add(key);
+                out.push(...pairDets);
+            }
+        }
+    }
+}
+/** Detect number+unit contradictions with surrounding sentence context. */
+function detectNumberContradiction(a, b, out) {
+    if (!areSameTopic(a, b))
+        return;
+    const srcA = a.content.source?.sourceId ?? '';
+    const srcB = b.content.source?.sourceId ?? '';
+    if (srcA && srcB && srcA === srcB)
+        return;
+    const textA = getNodeText(a);
+    const textB = getNodeText(b);
+    if (shareExactSentence(textA, textB))
+        return;
+    const COLLOQUIAL_RE = /\b(sure|certain|confident|probably|maybe)\b/i;
+    const numsA = extractNumbers(textA).filter((n) => !COLLOQUIAL_RE.test(extractSentence(textA, n.index)));
+    const numsB = extractNumbers(textB).filter((n) => !COLLOQUIAL_RE.test(extractSentence(textB, n.index)));
+    if (numsA.length === 0 || numsB.length === 0)
+        return;
+    const SKIP_UNITS = new Set(['percent', '%']);
+    const HTTP_STATUS_RE = /\b(status|response|http|code|error)\b/i;
+    const TIME_UNITS = new Set(['day', 'hour', 'minute', 'week', 'month', 'second']);
+    for (const na of numsA) {
+        if (SKIP_UNITS.has(normalizeUnit(na.unit)))
+            continue;
+        if (na.value >= 100 && na.value <= 599 && HTTP_STATUS_RE.test(extractSentence(textA, na.index)))
+            continue;
+        for (const nb of numsB) {
+            if (normalizeUnit(na.unit) !== normalizeUnit(nb.unit))
+                continue;
+            if (na.value === nb.value)
+                continue;
+            const sentA = extractSentence(textA, na.index);
+            const sentB = extractSentence(textB, nb.index);
+            if (sentA === sentB)
+                continue;
+            if (TIME_UNITS.has(normalizeUnit(na.unit))) {
+                const sentKwA = new Set(sentA.toLowerCase().split(/\W+/).filter((w) => w.length >= 4));
+                const sentKwB = new Set(sentB.toLowerCase().split(/\W+/).filter((w) => w.length >= 4));
+                const sentShared = [...sentKwA].filter((w) => sentKwB.has(w));
+                if (sentShared.length < 2)
+                    continue;
+            }
+            const kwA = rawKeywords(a);
+            const kwB = rawKeywords(b);
+            const sharedCount = [...kwA].filter((k) => kwB.has(k)).length;
+            if (sharedCount < 2)
+                continue;
+            const unitLabel = capitalizeFirst(normalizeUnit(na.unit));
+            out.push({
+                type: 'contradiction', severity: 'warning', nodeIds: [a.id, b.id],
+                description: `${unitLabel} inconsistency between ${a.title} and ${b.title}: "${na.raw}" vs "${nb.raw}"`,
+                suggestedAction: `Review "${a.title}" and "${b.title}" for consistency.`,
+                metadata: {
+                    nodeExcerpts: { [a.id]: sentA, [b.id]: sentB },
+                    claimA: na.raw, claimB: nb.raw, topic: `${unitLabel} values`,
+                },
+            });
+            return;
+        }
+    }
+}
+/** Detect boolean/opposing concept contradictions from raw content. */
+function detectBooleanContradiction(a, b, out) {
+    if (!areSameTopic(a, b))
+        return;
+    const srcA = a.content.source?.sourceId ?? '';
+    const srcB = b.content.source?.sourceId ?? '';
+    if (srcA && srcB && srcA === srcB)
+        return;
+    const textA = getNodeText(a);
+    const textB = getNodeText(b);
+    if (shareExactSentence(textA, textB))
+        return;
+    for (const [pA, pB, lA, lB] of BOOLEAN_PAIRS) {
+        const mAA = pA.exec(textA);
+        const mBB = pB.exec(textB);
+        const mAB = (!mAA || !mBB) ? pB.exec(textA) : null;
+        const mBA = mAB ? pA.exec(textB) : null;
+        const skipLabels = new Set(['enabled', 'disabled', 'required', 'optional', 'mandatory', 'not required']);
+        if (skipLabels.has(lA) || skipLabels.has(lB)) {
+            const ctxA = mAA ? extractSentence(textA, mAA.index) : mAB ? extractSentence(textA, mAB.index) : '';
+            const ctxB = mBB ? extractSentence(textB, mBB.index) : mBA ? extractSentence(textB, mBA.index) : '';
+            if (CONFIG_CONTEXT.test(ctxA) || CONFIG_CONTEXT.test(ctxB))
+                continue;
+        }
+        const match = mAA && mBB
+            ? { m1: mAA, m2: mBB, la: lA, lb: lB }
+            : mAB && mBA ? { m1: mAB, m2: mBA, la: lB, lb: lA } : null;
+        if (!match)
+            continue;
+        const sentA = extractSentence(textA, match.m1.index);
+        const sentB = extractSentence(textB, match.m2.index);
+        out.push({
+            type: 'contradiction', severity: 'warning', nodeIds: [a.id, b.id],
+            description: `Policy conflict between ${a.title} and ${b.title}: "${match.la}" vs "${match.lb}"`,
+            suggestedAction: `Review "${a.title}" and "${b.title}" for consistency.`,
+            metadata: {
+                nodeExcerpts: { [a.id]: sentA, [b.id]: sentB },
+                claimA: match.la, claimB: match.lb,
+                topic: `${match.la} vs ${match.lb}`,
+            },
+        });
+        return;
+    }
+}
+/** Check if two nodes are siblings (share the same parent chain prefix). */
+function areSiblings(a, b) {
+    const chainA = a.metadata?.['parentChain'];
+    const chainB = b.metadata?.['parentChain'];
+    if (!chainA?.length || !chainB?.length)
+        return false;
+    // Compare all but the last element (the document itself)
+    const parentA = chainA.slice(0, -1);
+    const parentB = chainB.slice(0, -1);
+    if (parentA.length === 0 || parentB.length === 0)
+        return false;
+    if (parentA.length !== parentB.length)
+        return false;
+    return parentA.every((p, i) => p.type === parentB[i].type && p.name === parentB[i].name);
+}
+/** Check if both nodes have authoritative analysis hints. */
+function areBothAuthoritative(a, b) {
+    const hintsA = a.metadata?.['analysisHints'];
+    const hintsB = b.metadata?.['analysisHints'];
+    return hintsA?.authoritative === true && hintsB?.authoritative === true;
+}
+/** Apply enrichment-based severity boosts to detections. */
+function applyEnrichmentBoosts(detections, nodes) {
+    const nodeMap = new Map(nodes.map((n) => [n.id, n]));
+    for (const det of detections) {
+        if (det.nodeIds.length < 2)
+            continue;
+        const a = nodeMap.get(det.nodeIds[0]);
+        const b = nodeMap.get(det.nodeIds[1]);
+        if (!a || !b)
+            continue;
+        // Both authoritative → always critical
+        if (areBothAuthoritative(a, b)) {
+            det.severity = 'critical';
+            det.metadata = { ...det.metadata, boostReason: 'both-authoritative' };
+            continue;
+        }
+        // Sibling docs (same parent) → upgrade info→warning, warning→critical
+        if (areSiblings(a, b) && det.severity !== 'critical') {
+            det.severity = det.severity === 'info' ? 'warning' : 'critical';
+            det.metadata = { ...det.metadata, boostReason: 'sibling-docs' };
+        }
+    }
+}
+/**
+ * Detect contradictions between knowledge nodes.
+ * Uses edges first, then LLM claim comparison (if available),
+ * otherwise falls back to heuristic detection.
+ */
+const detectContradictions = async (nodes, edges, llm) => {
+    const detections = [];
+    const seenPairs = new Set();
+    // 1. Edge-based contradictions (always)
+    detectEdgeContradictions(nodes, edges, detections, seenPairs);
+    // 2. Claim-based NLI detection (primary LLM path)
+    if (llm) {
+        const beforeNli = detections.length;
+        await detectClaimNliContradictions(nodes, llm, detections, seenPairs);
+        if (detections.length === beforeNli) {
+            await detectClaimContradictions(nodes, llm, detections, seenPairs);
+        }
+    }
+    // 3. Heuristic fallback (always runs for pairs not yet covered)
+    const beforeHeuristic = detections.length;
+    detectHeuristicContradictions(nodes, detections, seenPairs);
+    const MAX_HEURISTIC = 50;
+    if (detections.length - beforeHeuristic > MAX_HEURISTIC) {
+        detections.splice(beforeHeuristic + MAX_HEURISTIC);
+    }
+    // 4. Enrichment boosts (parentChain + analysisHints)
+    applyEnrichmentBoosts(detections, nodes);
+    return detections;
+};
+detectContradictions.preFilter = {
+    similarityThreshold: 0.6,
+    topK: 10,
+};
+export { detectContradictions, extractNumbers, areSiblings, areBothAuthoritative, };
+//# sourceMappingURL=contradictions.js.map

package/dist/duplicates.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Duplicate / split-truth detector.
+ * Finds knowledge nodes covering the same topic with different information.
+ * @module duplicates
+ */
+import type { DetectorFn } from '@useody/platform-core';
+/**
+ * Detect split truth between knowledge nodes using LLM analysis.
+ * Pre-filters by fact overlap before sending to LLM.
+ * Returns empty if no LLM is provided.
+ */
+declare const detectDuplicates: DetectorFn;
+export { detectDuplicates };
+//# sourceMappingURL=duplicates.d.ts.map

package/dist/duplicates.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"duplicates.d.ts","sourceRoot":"","sources":["../src/duplicates.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,OAAO,KAAK,EAIV,UAAU,EAEX,MAAM,uBAAuB,CAAC;AAmB/B;;;;GAIG;AACH,QAAA,MAAM,gBAAgB,EAAE,UA8FvB,CAAC;AAOF,OAAO,EAAE,gBAAgB,EAAE,CAAC"}

package/dist/duplicates.js

@@ -0,0 +1,95 @@
+import { parseLlmJsonResponse } from '@useody/platform-core';
+import { completeWithTimeout } from './helpers/llm-timeout.js';
+import { tokenize, sharedTokens } from './helpers/text-utils.js';
+/** Minimum shared tokens between two nodes to consider them topically related. */
+const MIN_SHARED_TOKENS = 1;
+/** Build a canonical pair key for deduplication. */
+function pairKey(a, b) {
+    return a < b ? `${a}:${b}` : `${b}:${a}`;
+}
+/** Extract fact tokens from a node for overlap checking. */
+function factTokens(node) {
+    const facts = node.content.facts ?? [];
+    return tokenize(`${node.title} ${facts.join(' ')}`);
+}
+/**
+ * Detect split truth between knowledge nodes using LLM analysis.
+ * Pre-filters by fact overlap before sending to LLM.
+ * Returns empty if no LLM is provided.
+ */
+const detectDuplicates = async (nodes, edges, llm) => {
+    const detections = [];
+    if (!llm)
+        return detections;
+    const seen = new Set();
+    let llmCalls = 0;
+    const MAX_LLM_CALLS = 20;
+    for (let i = 0; i < nodes.length && llmCalls < MAX_LLM_CALLS; i++) {
+        for (let j = i + 1; j < nodes.length && llmCalls < MAX_LLM_CALLS; j++) {
+            const a = nodes[i];
+            const b = nodes[j];
+            const key = pairKey(a.id, b.id);
+            if (seen.has(key))
+                continue;
+            seen.add(key);
+            const hasEdge = edges.some((e) => (e.sourceId === a.id && e.targetId === b.id) ||
+                (e.sourceId === b.id && e.targetId === a.id));
+            if (hasEdge)
+                continue;
+            const factsA = (a.content.facts ?? []).join('\n- ');
+            const factsB = (b.content.facts ?? []).join('\n- ');
+            if (!factsA && !factsB)
+                continue;
+            const tokensA = factTokens(a);
+            const tokensB = factTokens(b);
+            const overlap = sharedTokens(tokensA, tokensB);
+            if (overlap.length < MIN_SHARED_TOKENS)
+                continue;
+            llmCalls++;
+            const response = await completeWithTimeout(llm, [
+                {
+                    role: 'system',
+                    content: [
+                        'You detect SPLIT TRUTH: two documents about the SAME specific topic',
+                        'that state DIFFERENT or CONFLICTING facts.',
+                        'Rules:',
+                        '- Two documents about DIFFERENT topics = NOT split truth.',
+                        '- Two documents that AGREE on the same topic = NOT split truth.',
+                        '- Only flag when the SAME topic has CONFLICTING specific claims.',
+                        'Reply JSON only: {"splitTruth":boolean,"conflictA":string,"conflictB":string,"explanation":string}',
+                        'conflictA/B: the specific conflicting claim from each document (under 20 words each).',
+                        'If not split truth, set conflictA and conflictB to empty strings.',
+                        'Keep explanation under 25 words.',
+                    ].join(' '),
+                },
+                {
+                    role: 'user',
+                    content: `Document A: "${a.title}"\nFacts:\n- ${factsA || '(none)'}` +
+                        `\n\nDocument B: "${b.title}"\nFacts:\n- ${factsB || '(none)'}`,
+                },
+            ], { temperature: 0, maxTokens: 200 });
+            if (!response)
+                continue;
+            const parsed = parseLlmJsonResponse(response);
+            if (parsed.data?.splitTruth && parsed.data.explanation) {
+                const desc = parsed.data.conflictA && parsed.data.conflictB
+                    ? `Split truth: "${parsed.data.conflictA}" vs "${parsed.data.conflictB}"`
+                    : parsed.data.explanation;
+                detections.push({
+                    type: 'duplicate',
+                    severity: 'warning',
+                    nodeIds: [a.id, b.id],
+                    description: desc,
+                    suggestedAction: 'Review and consolidate into a single source of truth.',
+                });
+            }
+        }
+    }
+    return detections;
+};
+detectDuplicates.preFilter = {
+    similarityThreshold: 0.75,
+    topK: 5,
+};
+export { detectDuplicates };
+//# sourceMappingURL=duplicates.js.map

package/dist/health-score.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Deterministic health scoring from findings.
+ * Computes health scores without LLM — purely from the set of findings.
+ * @module health-score
+ */
+import type { ConsultingFinding, HealthScore } from './consultant-analysis.js';
+/**
+ * Compute a deterministic health score from findings.
+ * The LLM only identifies findings — this function derives
+ * repeatable scores purely from their categories and severities.
+ */
+export declare function computeDeterministicHealthScore(findings: ReadonlyArray<ConsultingFinding>): HealthScore;
+//# sourceMappingURL=health-score.d.ts.map

package/dist/health-score.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"health-score.d.ts","sourceRoot":"","sources":["../src/health-score.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,OAAO,KAAK,EAAE,iBAAiB,EAAmB,WAAW,EAAE,MAAM,0BAA0B,CAAC;AAmDhG;;;;GAIG;AACH,wBAAgB,+BAA+B,CAC7C,QAAQ,EAAE,aAAa,CAAC,iBAAiB,CAAC,GACzC,WAAW,CAWb"}

package/dist/health-score.js

@@ -0,0 +1,53 @@
+/** Severity penalty points. */
+const SEVERITY_PENALTY = {
+    critical: 25,
+    warning: 8,
+    info: 3,
+};
+/** Categories that penalize the consistency dimension. */
+const CONSISTENCY_CATEGORIES = new Set([
+    'contradiction',
+    'duplicate_truth',
+]);
+/** Categories that penalize the freshness dimension. */
+const FRESHNESS_CATEGORIES = new Set([
+    'stale_commitment',
+    'commitment_without_followthrough',
+]);
+/** Categories that penalize the ownership dimension. */
+const OWNERSHIP_CATEGORIES = new Set([
+    'ownership_gap',
+    'decision_without_context',
+]);
+/** Categories that penalize the coverage dimension. */
+const COVERAGE_CATEGORIES = new Set([
+    'tribal_knowledge',
+]);
+/** Clamp a value to the 0-100 range. */
+function clamp(v) {
+    return Math.max(0, Math.min(100, Math.round(v)));
+}
+/** Compute the penalty for a set of findings against a dimension. */
+function dimensionScore(findings, categories) {
+    let penalty = 0;
+    for (const f of findings) {
+        if (categories.has(f.category)) {
+            penalty += SEVERITY_PENALTY[f.severity] ?? 0;
+        }
+    }
+    return clamp(100 - penalty);
+}
+/**
+ * Compute a deterministic health score from findings.
+ * The LLM only identifies findings — this function derives
+ * repeatable scores purely from their categories and severities.
+ */
+export function computeDeterministicHealthScore(findings) {
+    const consistency = dimensionScore(findings, CONSISTENCY_CATEGORIES);
+    const freshness = dimensionScore(findings, FRESHNESS_CATEGORIES);
+    const ownership = dimensionScore(findings, OWNERSHIP_CATEGORIES);
+    const coverage = dimensionScore(findings, COVERAGE_CATEGORIES);
+    const overall = clamp(consistency * 0.35 + freshness * 0.25 + ownership * 0.2 + coverage * 0.2);
+    return { overall, consistency, freshness, ownership, coverage };
+}
+//# sourceMappingURL=health-score.js.map

package/dist/helpers/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Helper utilities for detectors.
+ * @module helpers
+ */
+export { completeWithTimeout } from './llm-timeout.js';
+export { normalize, tokenize, sharedTokens, lexicalScore, buildSignal, STOP_WORDS, } from './text-utils.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/helpers/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/helpers/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,EAAE,mBAAmB,EAAE,MAAM,kBAAkB,CAAC;AACvD,OAAO,EACL,SAAS,EACT,QAAQ,EACR,YAAY,EACZ,YAAY,EACZ,WAAW,EACX,UAAU,GACX,MAAM,iBAAiB,CAAC"}

package/dist/helpers/index.js

@@ -0,0 +1,7 @@
+/**
+ * Helper utilities for detectors.
+ * @module helpers
+ */
+export { completeWithTimeout } from './llm-timeout.js';
+export { normalize, tokenize, sharedTokens, lexicalScore, buildSignal, STOP_WORDS, } from './text-utils.js';
+//# sourceMappingURL=index.js.map

package/dist/helpers/llm-timeout.d.ts

@@ -0,0 +1,14 @@
+/**
+ * LLM completion with timeout guard.
+ * Returns empty string on transient errors (timeout, 5xx).
+ * Re-throws fatal errors (auth, quota) so the caller can surface them.
+ * @module helpers/llm-timeout
+ */
+import type { ChatMessage, LLMCompletionOptions, LLMProvider } from '@useody/platform-core';
+/**
+ * Call LLM with a timeout.
+ * Returns empty string on transient failures (timeout, 5xx).
+ * Re-throws fatal errors (401, 403) so the scan can fail fast.
+ */
+export declare function completeWithTimeout(llm: LLMProvider, messages: ChatMessage[], options: LLMCompletionOptions, timeoutMs?: number): Promise<string>;
+//# sourceMappingURL=llm-timeout.d.ts.map

package/dist/helpers/llm-timeout.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"llm-timeout.d.ts","sourceRoot":"","sources":["../../src/helpers/llm-timeout.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,OAAO,KAAK,EACV,WAAW,EACX,oBAAoB,EACpB,WAAW,EACZ,MAAM,uBAAuB,CAAC;AAY/B;;;;GAIG;AACH,wBAAsB,mBAAmB,CACvC,GAAG,EAAE,WAAW,EAChB,QAAQ,EAAE,WAAW,EAAE,EACvB,OAAO,EAAE,oBAAoB,EAC7B,SAAS,SAAqB,GAC7B,OAAO,CAAC,MAAM,CAAC,CAejB"}