@pellux/goodvibes-sdk 0.30.2 → 0.33.0

package/dist/platform/knowledge/semantic/answer.js

@@ -1,73 +1,28 @@
 import { normalizeKnowledgeSpaceId } from '../spaces.js';
-import { MAX_ANSWER_EVIDENCE_CHARS, clampText, readRecord, readString, readStringArray, uniqueStrings, } from './utils.js';
+import { readRecord, readString, readStringArray, uniqueStrings, } from './utils.js';
 import { hasConcreteFeatureSignal, isLowValueFeatureOrSpecText, isSemanticAnswerLinkedObject, } from './fact-quality.js';
 import { concreteAnswerGapSpaceId } from './answer-space.js';
 import { answerNeedsFeatureGap, cleanSynthesizedAnswer } from './answer-quality.js';
-import { clampTimeoutMs, withTimeoutOrNull } from './timeouts.js';
 import { renderFallbackAnswer } from './answer-fallback.js';
 import { rankAnswerSources } from './answer-source-ranking.js';
 import {} from './answer-common.js';
-import { filterFactsForQuery, hasFeatureIntentForQuery, renderFactForPrompt, } from './answer-fact-selection.js';
+import { filterFactsForQuery, hasFeatureIntentForQuery, } from './answer-fact-selection.js';
 import { collectAnswerEvidence, filterAnswerLinkedObjects, includeOfficialLinkedEvidence, includeOfficialLinkedSources, inferObjectLinkedObjects, shouldUseEvidenceLinkedObjects, toSearchResult, uniqueNodes, withAnswerSourceAliases, } from './answer-evidence.js';
 import { isRepairedAnswerGap, persistAnswerGap, persistAnswerGaps, shouldPersistNoMatchGap, } from './answer-gaps.js';
+import { answerConfidence, synthesizeAnswer } from './answer-llm.js';
 export async function answerKnowledgeQuery(context, input) {
     const spaceId = normalizeKnowledgeSpaceId(input.knowledgeSpaceId);
     const mode = input.mode ?? 'standard';
     const limit = Math.max(1, input.limit ?? 8);
     const objectProfiles = context.objectProfiles ?? [];
-    let evidence = collectAnswerEvidence(context.store, input, spaceId, limit, objectProfiles);
-    if (evidence.length === 0) {
-        const linkedObjects = input.includeLinkedObjects === false
-            ? []
-            : filterAnswerLinkedObjects(spaceId, input.query, [...(input.linkedObjects ?? [])], objectProfiles);
-        const linkedEvidence = includeOfficialLinkedEvidence(context.store, spaceId, input.query, evidence, linkedObjects, limit);
-        if (linkedEvidence.length > 0) {
-            evidence = linkedEvidence;
-        }
-        else {
-            const gap = shouldPersistNoMatchGap(spaceId, input.query, linkedObjects)
-                ? await persistAnswerGap(context.store, concreteAnswerGapSpaceId(spaceId, [], [], linkedObjects), input.query, 'No indexed evidence matched the question.', {
-                    linkedObjects,
-                })
-                : null;
-            return {
-                ok: true,
-                spaceId,
-                query: input.query,
-                answer: {
-                    text: input.noMatchMessage ?? `No knowledge matched "${input.query}".`,
-                    mode,
-                    confidence: 0,
-                    sources: [],
-                    linkedObjects,
-                    facts: [],
-                    gaps: gap ? [gap] : [],
-                    synthesized: false,
-                },
-                results: [],
-            };
-        }
-    }
-    let rawFacts = filterFactsForQuery(input.query, uniqueNodes(evidence.flatMap((item) => item.facts))).slice(0, 24);
-    const inferredObjectLinkedObjects = input.includeLinkedObjects === false
-        ? []
-        : inferObjectLinkedObjects(context.store, spaceId, input.query, context.objectProfiles ?? []);
-    const evidenceLinkedObjects = shouldUseEvidenceLinkedObjects(spaceId, input, inferredObjectLinkedObjects)
-        ? evidence.flatMap((item) => item.node ? [item.node] : [])
-        : [];
-    const rawLinkedObjects = input.includeLinkedObjects === false
-        ? []
-        : uniqueNodes([
-            ...(input.linkedObjects ?? []),
-            ...evidenceLinkedObjects,
-            ...inferredObjectLinkedObjects,
-            ...linkedObjectsFromFacts(context.store, rawFacts),
-        ])
-            .filter(isSemanticAnswerLinkedObject)
-            .slice(0, 24);
-    const linkedObjects = filterAnswerLinkedObjects(spaceId, input.query, rawLinkedObjects, objectProfiles);
+    const evidenceResolution = await resolveAnswerEvidence(context, input, spaceId, mode, limit, objectProfiles);
+    if (evidenceResolution.kind === 'no-match')
+        return evidenceResolution.result;
+    let evidence = evidenceResolution.evidence;
+    let rawFacts = collectRawAnswerFacts(input.query, evidence);
+    const linkedObjects = resolveAnswerLinkedObjects(context, input, spaceId, evidence, rawFacts, objectProfiles);
     evidence = includeOfficialLinkedEvidence(context.store, spaceId, input.query, evidence, linkedObjects, limit);
-    rawFacts = filterFactsForQuery(input.query, uniqueNodes(evidence.flatMap((item) => item.facts))).slice(0, 24);
+    rawFacts = collectRawAnswerFacts(input.query, evidence);
     const llmAnswer = await synthesizeAnswer(context.llm ?? null, input.query, mode, evidence, input.timeoutMs);
     const rankedSources = rankAnswerSources(evidence, rawFacts);
     const facts = withAnswerFactContract(context.store, rawFacts, linkedObjects);
@@ -105,41 +60,111 @@ export async function answerKnowledgeQuery(context, input) {
             linkedObjects,
         })
         : null;
-    const llmText = llmAnswer?.answer?.trim();
-    const cleanedLlmText = llmText ? cleanSynthesizedAnswer(llmText, featureIntent) : undefined;
-    const dropLowValueLlmAnswer = featureIntent && Boolean(cleanedLlmText) && isLowValueFeatureOrSpecText(cleanedLlmText ?? '');
-    const fallback = renderFallbackAnswer(input.query, mode, evidence, facts);
-    const hasZeroSourceBackedFeatureFacts = featureIntent
-        && linkedObjects.length > 0
-        && sources.length > 0
-        && facts.length === 0
-        && !fallback.synthesized;
-    const preferFallback = shouldPreferFallbackAnswer(featureIntent, cleanedLlmText, fallback.text);
-    const useFallback = hasZeroSourceBackedFeatureFacts || dropLowValueLlmAnswer || preferFallback || !cleanedLlmText;
-    const text = cleanSynthesizedAnswer((useFallback ? fallback.text : cleanedLlmText) || '', featureIntent, {
-        fallbackText: fallback.text,
+    const answerText = chooseAnswerText({
+        input,
+        mode,
+        featureIntent,
+        evidence,
+        facts,
+        sources,
+        linkedObjects,
+        llmAnswer,
     });
-    const synthesized = useFallback ? fallback.synthesized : Boolean(cleanedLlmText);
-    const confidence = input.includeConfidence === false
-        ? 0
-        : hasZeroSourceBackedFeatureFacts || dropLowValueLlmAnswer || (useFallback && !fallback.synthesized) ? 0 : answerConfidence(preferFallback ? null : llmAnswer, evidence);
     return {
         ok: true,
         spaceId,
         query: input.query,
         answer: {
-            text,
+            text: answerText.text,
             mode,
-            confidence,
+            confidence: answerText.confidence,
             sources: input.includeSources === false ? [] : sources,
             linkedObjects,
             facts,
             gaps: evidenceGap && !isRepairedAnswerGap(evidenceGap) ? uniqueNodes([...gaps, evidenceGap]) : gaps,
-            synthesized,
+            synthesized: answerText.synthesized,
         },
         results: evidence.map(toSearchResult),
     };
 }
+async function resolveAnswerEvidence(context, input, spaceId, mode, limit, objectProfiles) {
+    const evidence = collectAnswerEvidence(context.store, input, spaceId, limit, objectProfiles);
+    if (evidence.length > 0)
+        return { kind: 'matched', evidence };
+    const linkedObjects = input.includeLinkedObjects === false
+        ? []
+        : filterAnswerLinkedObjects(spaceId, input.query, [...(input.linkedObjects ?? [])], objectProfiles);
+    const linkedEvidence = includeOfficialLinkedEvidence(context.store, spaceId, input.query, evidence, linkedObjects, limit);
+    if (linkedEvidence.length > 0)
+        return { kind: 'matched', evidence: linkedEvidence };
+    const gap = shouldPersistNoMatchGap(spaceId, input.query, linkedObjects)
+        ? await persistAnswerGap(context.store, concreteAnswerGapSpaceId(spaceId, [], [], linkedObjects), input.query, 'No indexed evidence matched the question.', {
+            linkedObjects,
+        })
+        : null;
+    return {
+        kind: 'no-match',
+        result: {
+            ok: true,
+            spaceId,
+            query: input.query,
+            answer: {
+                text: input.noMatchMessage ?? `No knowledge matched "${input.query}".`,
+                mode,
+                confidence: 0,
+                sources: [],
+                linkedObjects,
+                facts: [],
+                gaps: gap ? [gap] : [],
+                synthesized: false,
+            },
+            results: [],
+        },
+    };
+}
+function collectRawAnswerFacts(query, evidence) {
+    return filterFactsForQuery(query, uniqueNodes(evidence.flatMap((item) => item.facts))).slice(0, 24);
+}
+function resolveAnswerLinkedObjects(context, input, spaceId, evidence, rawFacts, objectProfiles) {
+    if (input.includeLinkedObjects === false)
+        return [];
+    const inferredObjectLinkedObjects = inferObjectLinkedObjects(context.store, spaceId, input.query, objectProfiles);
+    const evidenceLinkedObjects = shouldUseEvidenceLinkedObjects(spaceId, input, inferredObjectLinkedObjects)
+        ? evidence.flatMap((item) => item.node ? [item.node] : [])
+        : [];
+    const rawLinkedObjects = uniqueNodes([
+        ...(input.linkedObjects ?? []),
+        ...evidenceLinkedObjects,
+        ...inferredObjectLinkedObjects,
+        ...linkedObjectsFromFacts(context.store, rawFacts),
+    ])
+        .filter(isSemanticAnswerLinkedObject)
+        .slice(0, 24);
+    return filterAnswerLinkedObjects(spaceId, input.query, rawLinkedObjects, objectProfiles);
+}
+function chooseAnswerText(options) {
+    const llmText = options.llmAnswer?.answer?.trim();
+    const cleanedLlmText = llmText ? cleanSynthesizedAnswer(llmText, options.featureIntent) : undefined;
+    const dropLowValueLlmAnswer = options.featureIntent && Boolean(cleanedLlmText) && isLowValueFeatureOrSpecText(cleanedLlmText ?? '');
+    const fallback = renderFallbackAnswer(options.input.query, options.mode, options.evidence, options.facts);
+    const hasZeroSourceBackedFeatureFacts = options.featureIntent
+        && options.linkedObjects.length > 0
+        && options.sources.length > 0
+        && options.facts.length === 0
+        && !fallback.synthesized;
+    const preferFallback = shouldPreferFallbackAnswer(options.featureIntent, cleanedLlmText, fallback.text);
+    const useFallback = hasZeroSourceBackedFeatureFacts || dropLowValueLlmAnswer || preferFallback || !cleanedLlmText;
+    const text = cleanSynthesizedAnswer((useFallback ? fallback.text : cleanedLlmText) || '', options.featureIntent, {
+        fallbackText: fallback.text,
+    });
+    const synthesized = useFallback ? fallback.synthesized : Boolean(cleanedLlmText);
+    const confidence = options.input.includeConfidence === false
+        ? 0
+        : hasZeroSourceBackedFeatureFacts || dropLowValueLlmAnswer || (useFallback && !fallback.synthesized)
+            ? 0
+            : answerConfidence(preferFallback ? null : options.llmAnswer, options.evidence);
+    return { text, synthesized, confidence };
+}
 function withAnswerFactContract(store, facts, linkedObjects) {
     if (facts.length === 0)
         return [];
@@ -277,98 +302,3 @@ function featureFamilyCount(text) {
         /\b(tuner|atsc|qam|ntsc|broadcast)\b/,
     ].filter((pattern) => pattern.test(lower)).length;
 }
-async function synthesizeAnswer(llm, query, mode, evidence, requestedTimeoutMs) {
-    if (!llm)
-        return null;
-    const timeoutMs = clampTimeoutMs(requestedTimeoutMs, 15_000, 1_000, 15_000);
-    const controller = new AbortController();
-    const response = await withTimeoutOrNull(llm.completeJson({
-        purpose: 'knowledge-answer-synthesis',
-        maxTokens: mode === 'detailed' ? 2200 : mode === 'concise' ? 700 : 1400,
-        signal: controller.signal,
-        timeoutMs,
-        systemPrompt: [
-            'You answer questions from a GoodVibes self-improving knowledge wiki.',
-            'Use only the supplied evidence. Synthesize the answer for the user intent rather than dumping snippets.',
-            'If evidence is insufficient, say what is missing. Prefer concrete features, specs, procedures, and relationships.',
-            'For feature or specification questions, ignore manual boilerplate about accessories, cable recommendations, USB/HDMI physical-fit guidance, button maps, remote aiming instructions, batteries, cleaning, servicing, safety, furniture, wall mounting, and future product changes unless the user asks about those topics.',
-            'Do not mention future features, specifications changing without notice, cable fit, USB extension cables, remote sensor aiming, service personnel, or child-safety/furniture/platform guidance in a feature/spec answer.',
-            'Return only JSON with answer, confidence, usedSourceIds, usedNodeIds, and optional gaps.',
-        ].join(' '),
-        prompt: JSON.stringify({
-            query,
-            mode,
-            evidence: renderEvidenceForPrompt(evidence),
-            outputShape: {
-                answer: 'source-backed natural language answer',
-                confidence: 0,
-                usedSourceIds: ['source ids used'],
-                usedNodeIds: ['node ids used'],
-                gaps: [{ question: 'unanswered follow-up gap', reason: 'missing evidence', severity: 'info' }],
-            },
-        }),
-    }), timeoutMs);
-    controller.abort();
-    return normalizeLlmAnswer(response);
-}
-function renderEvidenceForPrompt(evidence) {
-    let budget = MAX_ANSWER_EVIDENCE_CHARS;
-    const rendered = [];
-    for (const item of evidence.slice(0, 12)) {
-        if (budget <= 0)
-            break;
-        const factText = item.facts.slice(0, 16).map(renderFactForPrompt).join('\n');
-        const excerpt = clampText(item.excerpt, Math.min(1600, budget));
-        const record = {
-            kind: item.kind,
-            id: item.id,
-            title: item.title,
-            sourceId: item.source?.id,
-            nodeId: item.node?.id,
-            sourceType: item.source?.sourceType,
-            nodeKind: item.node?.kind,
-            excerpt,
-            facts: factText,
-        };
-        budget -= JSON.stringify(record).length;
-        rendered.push(record);
-    }
-    return rendered;
-}
-function normalizeLlmAnswer(value) {
-    const record = readRecord(value);
-    const answer = readString(record.answer);
-    if (!answer)
-        return null;
-    return {
-        answer,
-        ...(typeof record.confidence === 'number' ? { confidence: Math.max(0, Math.min(100, Math.round(record.confidence))) } : {}),
-        usedSourceIds: readStringArray(record.usedSourceIds),
-        usedNodeIds: readStringArray(record.usedNodeIds),
-        gaps: readGapArray(record.gaps),
-    };
-}
-function answerConfidence(answer, evidence) {
-    if (typeof answer?.confidence === 'number')
-        return answer.confidence;
-    const top = evidence[0]?.score ?? 0;
-    const factBoost = Math.min(35, uniqueNodes(evidence.flatMap((item) => item.facts)).length * 4);
-    return Math.max(10, Math.min(92, Math.round(top / 5) + factBoost));
-}
-function readGapArray(value) {
-    if (!Array.isArray(value))
-        return [];
-    return value.flatMap((entry) => {
-        const record = readRecord(entry);
-        const question = readString(record.question);
-        if (!question)
-            return [];
-        const severity = readString(record.severity);
-        return [{
-                question,
-                ...(readString(record.reason) ? { reason: readString(record.reason) } : {}),
-                ...(readString(record.subject) ? { subject: readString(record.subject) } : {}),
-                severity: severity === 'warning' || severity === 'error' ? severity : 'info',
-            }];
-    });
-}

package/dist/platform/knowledge/semantic/enrichment.d.ts

@@ -3,20 +3,20 @@ import type { KnowledgeNodeRecord, KnowledgeSourceRecord } from '../types.js';
 import type { KnowledgeSemanticLlm } from './types.js';
 export interface KnowledgeSemanticEnrichmentContext {
     readonly store: KnowledgeStore;
-    readonly llm?: KnowledgeSemanticLlm | null;
+    readonly llm?: KnowledgeSemanticLlm | null | undefined;
 }
 export interface EnrichKnowledgeSourceOptions {
-    readonly force?: boolean;
-    readonly knowledgeSpaceId?: string;
+    readonly force?: boolean | undefined;
+    readonly knowledgeSpaceId?: string | undefined;
 }
 export interface PersistedSemanticExtraction {
     readonly source: KnowledgeSourceRecord;
     readonly skipped: boolean;
-    readonly reason?: string;
-    readonly extractor?: 'llm' | 'deterministic';
+    readonly reason?: string | undefined;
+    readonly extractor?: 'llm' | 'deterministic' | undefined;
     readonly facts: readonly KnowledgeNodeRecord[];
     readonly entities: readonly KnowledgeNodeRecord[];
-    readonly wikiPage?: KnowledgeNodeRecord;
+    readonly wikiPage?: KnowledgeNodeRecord | undefined;
     readonly gaps: readonly KnowledgeNodeRecord[];
 }
 export declare function enrichKnowledgeSource(context: KnowledgeSemanticEnrichmentContext, source: KnowledgeSourceRecord, options?: EnrichKnowledgeSourceOptions): Promise<PersistedSemanticExtraction>;

package/dist/platform/knowledge/semantic/enrichment.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"enrichment.d.ts","sourceRoot":"","sources":["../../../../src/platform/knowledge/semantic/enrichment.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAClD,OAAO,KAAK,EAEV,mBAAmB,EACnB,qBAAqB,EACtB,MAAM,aAAa,CAAC;AACrB,OAAO,KAAK,EAKV,oBAAoB,EAErB,MAAM,YAAY,CAAC;AAsBpB,MAAM,WAAW,kCAAkC;IACjD,QAAQ,CAAC,KAAK,EAAE,cAAc,CAAC;IAC/B,QAAQ,CAAC,GAAG,CAAC,EAAE,oBAAoB,GAAG,IAAI,CAAC;CAC5C;AAED,MAAM,WAAW,4BAA4B;IAC3C,QAAQ,CAAC,KAAK,CAAC,EAAE,OAAO,CAAC;IACzB,QAAQ,CAAC,gBAAgB,CAAC,EAAE,MAAM,CAAC;CACpC;AAED,MAAM,WAAW,2BAA2B;IAC1C,QAAQ,CAAC,MAAM,EAAE,qBAAqB,CAAC;IACvC,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,SAAS,CAAC,EAAE,KAAK,GAAG,eAAe,CAAC;IAC7C,QAAQ,CAAC,KAAK,EAAE,SAAS,mBAAmB,EAAE,CAAC;IAC/C,QAAQ,CAAC,QAAQ,EAAE,SAAS,mBAAmB,EAAE,CAAC;IAClD,QAAQ,CAAC,QAAQ,CAAC,EAAE,mBAAmB,CAAC;IACxC,QAAQ,CAAC,IAAI,EAAE,SAAS,mBAAmB,EAAE,CAAC;CAC/C;AAED,wBAAsB,qBAAqB,CACzC,OAAO,EAAE,kCAAkC,EAC3C,MAAM,EAAE,qBAAqB,EAC7B,OAAO,GAAE,4BAAiC,GACzC,OAAO,CAAC,2BAA2B,CAAC,CA+BtC"}
+{"version":3,"file":"enrichment.d.ts","sourceRoot":"","sources":["../../../../src/platform/knowledge/semantic/enrichment.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAElD,OAAO,KAAK,EAGV,mBAAmB,EACnB,qBAAqB,EACtB,MAAM,aAAa,CAAC;AAErB,OAAO,KAAK,EAKV,oBAAoB,EAErB,MAAM,YAAY,CAAC;AAwBpB,MAAM,WAAW,kCAAkC;IACjD,QAAQ,CAAC,KAAK,EAAE,cAAc,CAAC;IAC/B,QAAQ,CAAC,GAAG,CAAC,EAAE,oBAAoB,GAAG,IAAI,GAAG,SAAS,CAAC;CACxD;AAED,MAAM,WAAW,4BAA4B;IAC3C,QAAQ,CAAC,KAAK,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;IACrC,QAAQ,CAAC,gBAAgB,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CAChD;AAED,MAAM,WAAW,2BAA2B;IAC1C,QAAQ,CAAC,MAAM,EAAE,qBAAqB,CAAC;IACvC,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IACrC,QAAQ,CAAC,SAAS,CAAC,EAAE,KAAK,GAAG,eAAe,GAAG,SAAS,CAAC;IACzD,QAAQ,CAAC,KAAK,EAAE,SAAS,mBAAmB,EAAE,CAAC;IAC/C,QAAQ,CAAC,QAAQ,EAAE,SAAS,mBAAmB,EAAE,CAAC;IAClD,QAAQ,CAAC,QAAQ,CAAC,EAAE,mBAAmB,GAAG,SAAS,CAAC;IACpD,QAAQ,CAAC,IAAI,EAAE,SAAS,mBAAmB,EAAE,CAAC;CAC/C;AAED,wBAAsB,qBAAqB,CACzC,OAAO,EAAE,kCAAkC,EAC3C,MAAM,EAAE,qBAAqB,EAC7B,OAAO,GAAE,4BAAiC,GACzC,OAAO,CAAC,2BAA2B,CAAC,CA+BtC"}

package/dist/platform/knowledge/semantic/enrichment.js

@@ -1,7 +1,10 @@
-import { MAX_SEMANTIC_SOURCE_CHARS, applySourceMetadata, clampText, normalizeWhitespace, readRecord, readString, readStringArray, semanticHash, semanticMetadata, semanticSlug, sourceKnowledgeSpace, sourceSemanticHash, sourceSemanticText, splitSentences, uniqueStrings, } from './utils.js';
+import { getKnowledgeSpaceId } from '../spaces.js';
+import { isActiveKnowledgeEdge } from '../projection-utils.js';
+import { MAX_SEMANTIC_SOURCE_CHARS, applySourceMetadata, clampText, normalizeWhitespace, readRecord, readString, readStringArray, semanticFactId, semanticHash, semanticMetadata, semanticSlug, sourceKnowledgeSpace, sourceSemanticHash, sourceSemanticText, splitSentences, uniqueStrings, } from './utils.js';
 import { canonicalRepairSubjectNodes } from './repair-subjects.js';
 import { hasConcreteFeatureSignal, isLowValueFeatureOrSpecText } from './fact-quality.js';
 import { deriveRepairProfileFacts } from './repair-profile.js';
+import { sourceAuthorityBoostForAnswer } from './answer-source-ranking.js';
 export async function enrichKnowledgeSource(context, source, options = {}) {
     const extraction = context.store.getExtractionBySourceId(source.id);
     const text = sourceSemanticText(source, extraction);
@@ -106,7 +109,7 @@ function normalizeSemanticExtraction(value) {
     };
 }
 function deterministicSemanticExtraction(source, extraction, text) {
-    const factText = cleanDeterministicSourceText(text);
+    const factText = cleanDeterministicSourceText(deterministicFactSourceText(extraction) || text);
     const sentences = splitSentences(factText);
     const profileFacts = deriveRepairProfileFacts({
         query: 'complete features specifications capabilities',
@@ -152,11 +155,33 @@ function deterministicSemanticExtraction(source, extraction, text) {
         extractor: 'deterministic',
     };
 }
+function deterministicFactSourceText(extraction) {
+    const structure = readRecord(extraction?.structure);
+    const nestedStructure = readRecord(structure.structure);
+    const metadata = readRecord(extraction?.metadata);
+    const nestedMetadata = readRecord(structure.metadata);
+    return uniqueStrings([
+        extraction?.title,
+        extraction?.summary,
+        extraction?.excerpt,
+        readString(structure.searchText),
+        readString(structure.text),
+        readString(structure.content),
+        readString(nestedStructure.searchText),
+        readString(nestedStructure.text),
+        readString(nestedStructure.content),
+        readString(metadata.searchText),
+        readString(metadata.text),
+        readString(nestedMetadata.searchText),
+        readString(nestedMetadata.text),
+    ]).join('\n\n');
+}
 function cleanDeterministicSourceText(text) {
     return normalizeWhitespace(text
         .replace(/https?:\/\/\S+/gi, ' ')
         .replace(/\bsemantic-gap-repair\b/gi, ' ')
         .replace(/\bhomegraph:\/\/\S+/gi, ' ')
+        .replace(/\b(?:manual|file|artifact):\/\/\S+/gi, ' ')
         .replace(/\b[a-z0-9-]+\.(?:com|net|org|io|dev|tv|ca|co\.uk)(?:\/\S*)?/gi, ' '));
 }
 function classifySentenceFact(sentence) {
@@ -226,15 +251,32 @@ async function persistSemanticExtraction(store, source, extraction, semantic, op
         const sourceLinkedObjectIds = factLinkedObjects.map((node) => node.id);
         const sourceTargetHints = factLinkedObjects.map((node) => ({ id: node.id, kind: node.kind, title: node.title }));
         const targetHints = fact.targetHints?.length ? fact.targetHints : sourceTargetHints;
+        const factId = semanticFactId({
+            spaceId,
+            kind: fact.kind,
+            title: fact.title,
+            value: fact.value,
+            summary: fact.summary,
+            subjectIds: sourceLinkedObjectIds,
+            fallbackScope: source.id,
+        });
+        const existingFact = store.getNode(factId);
+        const sourceIds = uniqueStrings([
+            ...readStringArray(existingFact?.metadata.sourceIds),
+            readString(existingFact?.metadata.sourceId),
+            existingFact?.sourceId,
+            source.id,
+        ]);
+        const primarySourceId = preferredSemanticFactSourceId(store, sourceIds, source.id);
         const node = await store.upsertNode({
-            id: `sem-fact-${semanticHash(spaceId, source.id, fact.kind, fact.title, fact.value ?? fact.summary)}`,
+            id: factId,
             kind: 'fact',
             slug: semanticSlug(`${spaceId}-${fact.kind}-${fact.title}-${fact.value ?? ''}`),
             title: fact.title,
             summary: fact.summary ?? fact.value ?? fact.evidence,
             aliases: fact.labels,
             confidence: fact.confidence ?? 70,
-            sourceId: source.id,
+            sourceId: primarySourceId,
             metadata: semanticMetadata(spaceId, {
                 semanticKind: 'fact',
                 factKind: fact.kind,
@@ -247,7 +289,8 @@ async function persistSemanticExtraction(store, source, extraction, semantic, op
                     subjectIds: sourceLinkedObjectIds,
                     linkedObjectIds: sourceLinkedObjectIds,
                 } : {}),
-                sourceId: source.id,
+                sourceId: primarySourceId,
+                sourceIds,
                 extractionId: extraction?.id,
                 extractor: semantic.extractor,
                 textHash: options.textHash,
@@ -314,14 +357,20 @@ async function persistSemanticExtraction(store, source, extraction, semantic, op
 function shouldPersistSemanticFact(fact) {
     if (!['feature', 'capability', 'specification', 'compatibility', 'configuration'].includes(fact.kind))
         return true;
-    const text = semanticInputFactText([
+    const signalText = semanticInputFactText([
         fact.title,
         fact.summary,
         fact.value,
         fact.evidence,
         ...(fact.labels ?? []),
     ]);
-    return hasConcreteFeatureSignal(text) && !isLowValueFeatureOrSpecText(text);
+    const qualityText = semanticInputFactText([
+        fact.summary,
+        fact.value,
+        fact.evidence,
+        ...(fact.labels ?? []),
+    ]) || signalText;
+    return hasConcreteFeatureSignal(signalText) && !isLowValueFeatureOrSpecText(qualityText);
 }
 function semanticInputFactText(parts) {
     const uniqueParts = [];
@@ -352,29 +401,131 @@ function sourceLinkedObjectsForFact(linkedObjects, fact) {
 }
 async function markPreviousSemanticNodesStale(store, sourceId, spaceId, activeIds) {
     const supersededAt = Date.now();
-    const semanticNodes = store.listNodesInSpace(spaceId).filter((node) => (node.sourceId === sourceId
+    const semanticNodes = store.listNodesInSpace(spaceId).filter((node) => (semanticNodeReferencesSource(node, sourceId)
         && typeof node.metadata.semanticKind === 'string'
         && node.status !== 'stale'
         && !activeIds.has(node.id)));
-    for (const node of semanticNodes) {
-        await store.upsertNode({
-            id: node.id,
-            kind: node.kind,
-            slug: node.slug,
-            title: node.title,
-            summary: node.summary,
-            aliases: node.aliases,
-            status: 'stale',
-            confidence: node.confidence,
-            ...(node.sourceId ? { sourceId: node.sourceId } : {}),
-            metadata: {
-                ...node.metadata,
+    await store.batch(async () => {
+        for (const node of semanticNodes) {
+            if (await detachSupersededSourceFromSharedFact(store, sourceId, spaceId, node, supersededAt))
+                continue;
+            await store.upsertNode({
+                id: node.id,
+                kind: node.kind,
+                slug: node.slug,
+                title: node.title,
+                summary: node.summary,
+                aliases: node.aliases,
+                status: 'stale',
+                confidence: node.confidence,
+                ...(node.sourceId ? { sourceId: node.sourceId } : {}),
+                metadata: {
+                    ...node.metadata,
+                    supersededAt,
+                    supersededInSpaceId: spaceId,
+                },
+            });
+        }
+    });
+}
+function semanticNodeReferencesSource(node, sourceId) {
+    if (node.sourceId === sourceId)
+        return true;
+    if (readString(node.metadata.sourceId) === sourceId)
+        return true;
+    return node.metadata.semanticKind === 'fact' && readStringArray(node.metadata.sourceIds).includes(sourceId);
+}
+async function detachSupersededSourceFromSharedFact(store, sourceId, spaceId, node, supersededAt) {
+    if (node.metadata.semanticKind !== 'fact')
+        return false;
+    const supportingSourceIds = activeSemanticFactSupportSourceIds(store, node, sourceId, spaceId);
+    if (supportingSourceIds.length === 0)
+        return false;
+    const primarySourceId = preferredSemanticFactSourceId(store, supportingSourceIds, supportingSourceIds[0]);
+    await deactivateSemanticFactSupport(store, sourceId, node.id, spaceId, supersededAt);
+    await store.upsertNode({
+        id: node.id,
+        kind: node.kind,
+        slug: node.slug,
+        title: node.title,
+        summary: node.summary,
+        aliases: node.aliases,
+        status: node.status,
+        confidence: node.confidence,
+        sourceId: primarySourceId,
+        metadata: semanticMetadata(spaceId, {
+            ...node.metadata,
+            sourceId: primarySourceId,
+            sourceIds: supportingSourceIds,
+            detachedSourceIds: uniqueStrings([
+                ...readStringArray(node.metadata.detachedSourceIds),
+                sourceId,
+            ]),
+            sourceDetachedAt: supersededAt,
+        }),
+    });
+    return true;
+}
+function activeSemanticFactSupportSourceIds(store, fact, supersededSourceId, spaceId) {
+    return uniqueStrings([
+        ...readStringArray(fact.metadata.sourceIds),
+        readString(fact.metadata.sourceId),
+        fact.sourceId,
+        ...store.listEdges()
+            .filter((edge) => edgeSupportsFact(edge, fact.id, spaceId))
+            .map((edge) => edge.fromId),
+    ])
+        .filter((sourceId) => sourceId !== supersededSourceId)
+        .filter((sourceId) => {
+        const source = store.getSource(sourceId);
+        return Boolean(source && source.status === 'indexed' && getKnowledgeSpaceId(source) === spaceId);
+    });
+}
+async function deactivateSemanticFactSupport(store, sourceId, factId, spaceId, supersededAt) {
+    const edges = store.listEdges().filter((edge) => (edge.fromKind === 'source'
+        && edge.fromId === sourceId
+        && edge.toKind === 'node'
+        && edge.toId === factId
+        && edge.relation === 'supports_fact'
+        && isActiveKnowledgeEdge(edge)));
+    for (const edge of edges) {
+        await store.upsertEdge({
+            fromKind: edge.fromKind,
+            fromId: edge.fromId,
+            toKind: edge.toKind,
+            toId: edge.toId,
+            relation: edge.relation,
+            weight: 0,
+            metadata: semanticMetadata(spaceId, {
+                ...edge.metadata,
+                deleted: true,
                 supersededAt,
-                supersededInSpaceId: spaceId,
-            },
+            }),
         });
     }
 }
+function edgeSupportsFact(edge, factId, spaceId) {
+    return isActiveKnowledgeEdge(edge)
+        && edge.fromKind === 'source'
+        && edge.toKind === 'node'
+        && edge.toId === factId
+        && edge.relation === 'supports_fact'
+        && getKnowledgeSpaceId(edge) === spaceId;
+}
+function preferredSemanticFactSourceId(store, sourceIds, fallbackSourceId) {
+    const candidates = uniqueStrings(sourceIds)
+        .map((sourceId) => store.getSource(sourceId))
+        .filter((source) => Boolean(source && source.status !== 'stale'));
+    if (candidates.length === 0)
+        return fallbackSourceId;
+    return candidates
+        .sort((left, right) => semanticFactSourceQuality(right) - semanticFactSourceQuality(left) || left.id.localeCompare(right.id))[0].id;
+}
+function semanticFactSourceQuality(source) {
+    return sourceAuthorityBoostForAnswer(source)
+        + (source.status === 'indexed' ? 40 : source.status === 'pending' ? 5 : 0)
+        + (source.sourceType === 'manual' || source.sourceType === 'document' ? 12 : source.sourceType === 'url' ? 8 : 0);
+}
 async function persistWikiPage(store, source, semantic, spaceId, textHash) {
     const markdown = semantic.wikiPage?.markdown ?? renderDeterministicWikiPage(source, semantic.facts);
     if (!markdown.trim())

package/dist/platform/knowledge/semantic/fact-quality.d.ts

@@ -1,7 +1,7 @@
 import type { KnowledgeNodeRecord } from '../types.js';
 export interface KnowledgePageFactQualityOptions {
-    readonly allowedFactKinds?: ReadonlySet<string>;
-    readonly rejectRemoteAccessoryDetails?: boolean;
+    readonly allowedFactKinds?: ReadonlySet<string> | undefined;
+    readonly rejectRemoteAccessoryDetails?: boolean | undefined;
 }
 export declare function isSemanticAnswerLinkedObject(node: KnowledgeNodeRecord): boolean;
 export declare function semanticFactText(fact: KnowledgeNodeRecord): string;

package/dist/platform/knowledge/semantic/fact-quality.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"fact-quality.d.ts","sourceRoot":"","sources":["../../../../src/platform/knowledge/semantic/fact-quality.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAC;AAcvD,MAAM,WAAW,+BAA+B;IAC9C,QAAQ,CAAC,gBAAgB,CAAC,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;IAChD,QAAQ,CAAC,4BAA4B,CAAC,EAAE,OAAO,CAAC;CACjD;AAED,wBAAgB,4BAA4B,CAAC,IAAI,EAAE,mBAAmB,GAAG,OAAO,CAK/E;AAED,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,mBAAmB,GAAG,MAAM,CAqBlE;AAED,wBAAgB,2BAA2B,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAoKjE;AAsCD,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAE9D;AAED,wBAAgB,yBAAyB,CACvC,IAAI,EAAE,mBAAmB,EACzB,OAAO,GAAE,+BAAoC,GAC5C,OAAO,CAsBT"}
+{"version":3,"file":"fact-quality.d.ts","sourceRoot":"","sources":["../../../../src/platform/knowledge/semantic/fact-quality.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAC;AAcvD,MAAM,WAAW,+BAA+B;IAC9C,QAAQ,CAAC,gBAAgB,CAAC,EAAE,WAAW,CAAC,MAAM,CAAC,GAAG,SAAS,CAAC;IAC5D,QAAQ,CAAC,4BAA4B,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;CAC7D;AAED,wBAAgB,4BAA4B,CAAC,IAAI,EAAE,mBAAmB,GAAG,OAAO,CAK/E;AAED,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,mBAAmB,GAAG,MAAM,CAQlE;AAmCD,wBAAgB,2BAA2B,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAuKjE;AAsCD,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAE9D;AAED,wBAAgB,yBAAyB,CACvC,IAAI,EAAE,mBAAmB,EACzB,OAAO,GAAE,+BAAoC,GAC5C,OAAO,CAsBT"}