@pellux/goodvibes-sdk 0.28.13 → 0.28.15

package/dist/_internal/platform/knowledge/semantic/gap-repair.js

@@ -17,21 +17,28 @@ async function repairKnowledgeGapsWithWeb(request, options) {
     const existing = existingSources(request);
     const sourceLimit = Math.max(2, Math.min(5, request.maxSources ?? options.maxSources ?? options.maxIngest ?? 5));
     const searchLimit = Math.max(1, Math.min(5, options.maxSearches ?? queries.length));
+    const existingCandidates = selectExistingRepairSources(request, options, sourceLimit);
     const searchResults = new Map();
     const providerIds = new Set();
     let lastError;
     for (const query of queries.slice(0, searchLimit)) {
+        if (request.signal?.aborted || deadlineExceeded(request.deadlineAt))
+            break;
         try {
+            const timeoutMs = operationTimeout(request.deadlineAt, options.searchTimeoutMs ?? 8_000);
+            if (timeoutMs <= 0)
+                break;
             const response = await withTimeout(options.searchService.search({
                 query,
                 maxResults: Math.max(sourceLimit, Math.min(8, options.maxResults ?? sourceLimit)),
                 verbosity: 'snippets',
                 safeSearch: 'moderate',
+                trustedHosts: trustedHostsForRepair(request),
                 metadata: {
                     purpose: 'knowledge-gap-repair',
                     knowledgeSpaceId: request.spaceId,
                 },
-            }), Math.max(1_000, options.searchTimeoutMs ?? 8_000), 'Semantic gap repair search timed out.');
+            }), Math.max(1_000, timeoutMs), 'Semantic gap repair search timed out.');
             if (response.providerId)
                 providerIds.add(response.providerId);
             for (const result of response.results) {
@@ -40,30 +47,44 @@ async function repairKnowledgeGapsWithWeb(request, options) {
                     continue;
                 searchResults.set(canonical, { ...result, searchQuery: query, searchProviderId: response.providerId });
             }
-            const partial = selectGapRepairCandidates([...searchResults.values()], existing, options, request, sourceLimit);
-            if (partial.length >= Math.max(2, options.minDistinctDomains ?? 2))
+            const partial = mergeRepairCandidates(existingCandidates, selectGapRepairCandidates([...searchResults.values()], existing, options, request, sourceLimit), sourceLimit);
+            if (hasEnoughRepairEvidence(partial, options))
                 break;
         }
         catch (error) {
             lastError = error instanceof Error ? error.message : String(error);
+            if (deadlineExceeded(request.deadlineAt))
+                break;
         }
     }
     const allResults = [...searchResults.values()];
-    const candidates = selectGapRepairCandidates(allResults, existing, options, request, sourceLimit);
-    if (candidates.length < Math.max(2, options.minDistinctDomains ?? 2)) {
+    const candidates = mergeRepairCandidates(existingCandidates, selectGapRepairCandidates(allResults, existing, options, request, sourceLimit), sourceLimit);
+    if (!hasEnoughRepairEvidence(candidates, options)) {
         return {
             searched: true,
             query: queries[0],
+            evidenceSufficient: false,
+            acceptedSourceIds: existingCandidates.map((candidate) => candidate.existingSourceId).filter((id) => Boolean(id)),
             ingestedSourceIds: [],
             skippedUrls: allResults.map((result) => result.url),
-            sourceAssessments: buildSourceAssessments(allResults, candidates, existing, options, request),
-            reason: lastError ?? 'Fewer than two distinct external sources were found for source-backed gap repair.',
+            sourceAssessments: [
+                ...existingCandidates.map((candidate) => candidateToAssessment(candidate, true)),
+                ...buildSourceAssessments(allResults, candidates, existing, options, request),
+            ],
+            reason: lastError ?? 'Insufficient distinct source-backed evidence was found for gap repair.',
         };
     }
     const ingestedSourceIds = [];
     const skippedUrls = [];
-    for (const result of candidates.slice(0, Math.max(2, Math.min(sourceLimit, options.maxIngest ?? sourceLimit)))) {
+    const existingSourceIds = candidates.map((candidate) => candidate.existingSourceId).filter((id) => Boolean(id));
+    const newCandidates = candidates.filter((candidate) => !candidate.existingSourceId);
+    for (const result of newCandidates.slice(0, Math.max(0, Math.min(sourceLimit - existingSourceIds.length, options.maxIngest ?? sourceLimit)))) {
+        if (request.signal?.aborted || deadlineExceeded(request.deadlineAt))
+            break;
         try {
+            const timeoutMs = operationTimeout(request.deadlineAt, options.ingestTimeoutMs ?? 10_000);
+            if (timeoutMs <= 0)
+                break;
             const ingested = await withTimeout(options.ingestService.ingestUrl({
                 url: result.url,
                 ...(result.title ? { title: result.title } : {}),
@@ -92,7 +113,7 @@ async function repairKnowledgeGapsWithWeb(request, options) {
                         searchedAt: Date.now(),
                     },
                 },
-            }), Math.max(1_000, options.ingestTimeoutMs ?? 10_000), 'Semantic gap repair source ingest timed out.');
+            }), Math.max(1_000, timeoutMs), 'Semantic gap repair source ingest timed out.');
             if (ingested.source.status === 'indexed' || ingested.source.status === 'pending') {
                 ingestedSourceIds.push(ingested.source.id);
             }
@@ -105,10 +126,15 @@ async function repairKnowledgeGapsWithWeb(request, options) {
     return {
         searched: true,
         query: queries[0],
+        evidenceSufficient: true,
+        acceptedSourceIds: uniqueStrings([...existingSourceIds, ...ingestedSourceIds]),
         ingestedSourceIds,
         skippedUrls,
-        sourceAssessments: buildSourceAssessments(allResults, candidates, existing, options, request),
-        ...(ingestedSourceIds.length < 2 ? { reason: 'Gap repair searched but fewer than two sources were ingested.' } : {}),
+        sourceAssessments: [
+            ...existingCandidates.map((candidate) => candidateToAssessment(candidate, candidates.some((entry) => entry.url === candidate.url))),
+            ...buildSourceAssessments(allResults, candidates, existing, options, request),
+        ],
+        ...(existingSourceIds.length + ingestedSourceIds.length < 1 ? { reason: 'Gap repair searched but did not accept usable sources.' } : {}),
     };
 }
 function buildGapRepairQueries(request) {
@@ -195,9 +221,47 @@ function selectGapRepairCandidates(results, existingCanonicalUris, options, requ
         byDomain.set(domain, { ...result, confidence: assessment.confidence, reasons: assessment.reasons });
     }
     return [...byDomain.values()]
-        .sort((left, right) => right.confidence - left.confidence || left.rank - right.rank)
+        .sort(compareRepairCandidates)
         .slice(0, sourceLimit);
 }
+function selectExistingRepairSources(request, options, sourceLimit) {
+    const minimumConfidence = Math.max(1, Math.min(100, options.minConfidence ?? 70));
+    const byDomain = new Map();
+    for (const source of request.sources) {
+        if (source.status !== 'indexed' || isGeneratedOrSyntheticSource(source))
+            continue;
+        const url = source.sourceUri ?? source.canonicalUri;
+        if (!url)
+            continue;
+        const domain = safeDomain(url);
+        if (!domain || byDomain.has(domain))
+            continue;
+        const snippet = [source.summary, source.description, source.tags.join(' ')].filter(Boolean).join(' ');
+        const result = {
+            rank: 0,
+            url,
+            domain,
+            displayUrl: url,
+            type: 'organic',
+            providerId: 'indexed',
+            metadata: source.metadata,
+            searchQuery: request.query,
+            searchProviderId: 'indexed',
+            ...(source.title ? { title: source.title } : {}),
+            ...(snippet ? { snippet } : {}),
+        };
+        const assessment = assessGapRepairSource(result, request.query, request);
+        if (assessment.confidence < minimumConfidence && !isOfficialOrVendorSource(assessment.reasons))
+            continue;
+        byDomain.set(domain, {
+            ...result,
+            existingSourceId: source.id,
+            confidence: Math.max(assessment.confidence, isOfficialOrVendorSource(assessment.reasons) ? 82 : assessment.confidence),
+            reasons: uniqueStrings([...assessment.reasons, 'already-indexed']),
+        });
+    }
+    return [...byDomain.values()].sort(compareRepairCandidates).slice(0, sourceLimit);
+}
 function assessGapRepairSource(result, query, request) {
     const searchable = [result.title, result.snippet, result.url, result.domain].filter(Boolean).join(' ').toLowerCase();
     const reasons = [];
@@ -240,9 +304,13 @@ function assessGapRepairSource(result, query, request) {
         reasons.push('source-purpose');
     }
     if (domain && identities.manufacturers.some((manufacturer) => manufacturer.length >= 2 && domain.includes(manufacturer.toLowerCase()))) {
-        score += 10;
+        score += 28;
         reasons.push('manufacturer-domain');
     }
+    if (domain && isOfficialVendorDomain(domain, identities.manufacturers)) {
+        score += 28;
+        reasons.push('official-vendor-domain');
+    }
     return {
         url: result.url,
         ...(result.title ? { title: result.title } : {}),
@@ -254,6 +322,36 @@ function assessGapRepairSource(result, query, request) {
         ...(reasons.length > 0 ? { trustReason: reasons.join(', ') } : {}),
     };
 }
+function mergeRepairCandidates(existingCandidates, searchCandidates, sourceLimit) {
+    const byCanonical = new Map();
+    for (const candidate of [...existingCandidates, ...searchCandidates]) {
+        const key = canonicalizeUri(candidate.url) ?? candidate.url;
+        const current = byCanonical.get(key);
+        if (!current || compareRepairCandidates(candidate, current) < 0)
+            byCanonical.set(key, candidate);
+    }
+    return [...byCanonical.values()].sort(compareRepairCandidates).slice(0, sourceLimit);
+}
+function hasEnoughRepairEvidence(candidates, options) {
+    if (candidates.some((candidate) => candidate.reasons.includes('official-vendor-domain')))
+        return true;
+    const required = Math.max(2, options.minDistinctDomains ?? 2);
+    return new Set(candidates.map((candidate) => candidate.domain ?? safeDomain(candidate.url)).filter(Boolean)).size >= required;
+}
+function compareRepairCandidates(left, right) {
+    return sourceAuthorityScore(right) - sourceAuthorityScore(left)
+        || right.confidence - left.confidence
+        || left.rank - right.rank;
+}
+function sourceAuthorityScore(candidate) {
+    if (candidate.reasons.includes('official-vendor-domain'))
+        return 3;
+    if (candidate.reasons.includes('manufacturer-domain'))
+        return 2;
+    if (candidate.existingSourceId)
+        return 1;
+    return 0;
+}
 function buildSourceAssessments(results, candidates, existingCanonicalUris, options, request) {
     const accepted = new Set(candidates.map((candidate) => canonicalizeUri(candidate.url)));
     const acceptedDomains = new Set(candidates.map((candidate) => candidate.domain ?? safeDomain(candidate.url)).filter(Boolean));
@@ -284,6 +382,20 @@ function buildSourceAssessments(results, candidates, existingCanonicalUris, opti
         };
     });
 }
+function candidateToAssessment(candidate, accepted) {
+    return {
+        url: candidate.url,
+        ...(candidate.title ? { title: candidate.title } : {}),
+        ...(candidate.domain ? { domain: candidate.domain } : {}),
+        rank: candidate.rank,
+        query: candidate.searchQuery,
+        accepted,
+        confidence: candidate.confidence,
+        reasons: candidate.reasons,
+        trustReason: candidate.reasons.join(', '),
+        ...(accepted ? {} : { rejectionReason: 'not-selected' }),
+    };
+}
 function sourceIdentityHints(request) {
     const subjects = uniqueStrings([
         ...request.linkedObjects.flatMap((node) => [node.title, ...node.aliases]),
@@ -298,9 +410,26 @@ function sourceIdentityHints(request) {
     const manufacturers = uniqueStrings(request.linkedObjects.flatMap((node) => [
         readString(node.metadata.manufacturer),
         readString(node.metadata.vendor),
-    ]).concat(request.sources.flatMap((source) => manufacturerHints(`${source.title ?? ''} ${source.sourceUri ?? ''} ${source.canonicalUri ?? ''}`))));
+    ]).concat(request.sources.flatMap((source) => manufacturerHints(`${source.title ?? ''} ${source.sourceUri ?? ''} ${source.canonicalUri ?? ''}`)))
+        .map((manufacturer) => manufacturer?.trim().toLowerCase())
+        .filter((manufacturer) => Boolean(manufacturer)));
     return { models, manufacturers, subjects };
 }
+function trustedHostsForRepair(request) {
+    const manufacturers = sourceIdentityHints(request).manufacturers;
+    const hosts = [];
+    if (manufacturers.includes('lg'))
+        hosts.push('lg.com', 'www.lg.com');
+    if (manufacturers.includes('sony'))
+        hosts.push('sony.com', 'www.sony.com');
+    if (manufacturers.includes('samsung'))
+        hosts.push('samsung.com', 'www.samsung.com');
+    if (manufacturers.includes('apple'))
+        hosts.push('apple.com', 'support.apple.com');
+    if (manufacturers.includes('espressif') || manufacturers.includes('esp32'))
+        hosts.push('espressif.com', 'docs.espressif.com');
+    return uniqueStrings(hosts);
+}
 function isGenericSubject(value) {
     return /^(tv|television|device|manual|user guide|owner manual|home assistant|service|provider|integration)$/i.test(value.trim());
 }
@@ -311,6 +440,34 @@ function manufacturerHints(value) {
     const hints = value.match(/\b(lg|samsung|sony|vizio|tcl|hisense|philips|panasonic|kasa|tp-link|ecobee|honeywell|ring|arlo|nest|eufy|aqara|sonoff|shelly|lutron|leviton|ikea|bosch|ge|whirlpool|frigidaire|apple|espressif|esp32|nabu casa|home assistant)\b/gi) ?? [];
     return uniqueStrings(hints.map((hint) => hint.toLowerCase()));
 }
+function isGeneratedOrSyntheticSource(source) {
+    return source.tags.includes('generated-page')
+        || source.metadata.projectionKind === 'device-passport'
+        || source.metadata.projectionKind === 'room-page';
+}
+function isOfficialVendorDomain(domain, manufacturers) {
+    const lower = domain.toLowerCase();
+    if (manufacturers.some((manufacturer) => manufacturer === 'lg' && /(^|\.)lg\.com$/.test(lower)))
+        return true;
+    if (manufacturers.some((manufacturer) => manufacturer === 'sony' && /(^|\.)sony\.(com|net)$/.test(lower)))
+        return true;
+    if (manufacturers.some((manufacturer) => manufacturer === 'samsung' && /(^|\.)samsung\.com$/.test(lower)))
+        return true;
+    if (manufacturers.some((manufacturer) => manufacturer === 'apple' && /(^|\.)apple\.com$/.test(lower)))
+        return true;
+    return manufacturers.some((manufacturer) => manufacturer.length >= 4 && lower.includes(manufacturer.toLowerCase()) && /\b(support|docs?|developer|product)\b/.test(lower));
+}
+function isOfficialOrVendorSource(reasons) {
+    return reasons.includes('official-vendor-domain') || reasons.includes('manufacturer-domain');
+}
+function deadlineExceeded(deadlineAt) {
+    return typeof deadlineAt === 'number' && Date.now() >= deadlineAt;
+}
+function operationTimeout(deadlineAt, fallbackMs) {
+    if (typeof deadlineAt !== 'number')
+        return fallbackMs;
+    return Math.min(fallbackMs, Math.max(0, deadlineAt - Date.now()));
+}
 function hasIdentity(searchable, value) {
     const normalized = value.trim().toLowerCase();
     if (!normalized)

package/dist/_internal/platform/knowledge/semantic/self-improvement-promotion.d.ts

@@ -0,0 +1,11 @@
+import type { KnowledgeStore } from '../store.js';
+import type { KnowledgeNodeRecord, KnowledgeRefinementTaskRecord } from '../types.js';
+export interface SelfImprovePromotionContext {
+    readonly store: KnowledgeStore;
+    readonly enrichSource?: (sourceId: string, options: {
+        readonly force?: boolean;
+        readonly knowledgeSpaceId?: string;
+    }) => Promise<unknown>;
+}
+export declare function promoteRepairSources(context: SelfImprovePromotionContext, spaceId: string, gap: KnowledgeNodeRecord, sourceIds: readonly string[], task: KnowledgeRefinementTaskRecord, deadlineAt: number): Promise<void>;
+//# sourceMappingURL=self-improvement-promotion.d.ts.map

package/dist/_internal/platform/knowledge/semantic/self-improvement-promotion.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"self-improvement-promotion.d.ts","sourceRoot":"","sources":["../../../../../src/_internal/platform/knowledge/semantic/self-improvement-promotion.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAClD,OAAO,KAAK,EAEV,mBAAmB,EACnB,6BAA6B,EAE9B,MAAM,aAAa,CAAC;AAiBrB,MAAM,WAAW,2BAA2B;IAC1C,QAAQ,CAAC,KAAK,EAAE,cAAc,CAAC;IAC/B,QAAQ,CAAC,YAAY,CAAC,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE;QAAE,QAAQ,CAAC,KAAK,CAAC,EAAE,OAAO,CAAC;QAAC,QAAQ,CAAC,gBAAgB,CAAC,EAAE,MAAM,CAAA;KAAE,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;CAC3I;AAED,wBAAsB,oBAAoB,CACxC,OAAO,EAAE,2BAA2B,EACpC,OAAO,EAAE,MAAM,EACf,GAAG,EAAE,mBAAmB,EACxB,SAAS,EAAE,SAAS,MAAM,EAAE,EAC5B,IAAI,EAAE,6BAA6B,EACnC,UAAU,EAAE,MAAM,GACjB,OAAO,CAAC,IAAI,CAAC,CAoBf"}

package/dist/_internal/platform/knowledge/semantic/self-improvement-promotion.js

@@ -0,0 +1,243 @@
+import { yieldEvery, yieldToEventLoop } from '../cooperative.js';
+import { getKnowledgeSpaceId } from '../spaces.js';
+import { hasConcreteFeatureSignal, isLowValueFeatureOrSpecText } from './fact-quality.js';
+import { updateRefinementTask } from './self-improvement-tasks.js';
+import { withTimeout } from './timeouts.js';
+import { clampText, normalizeWhitespace, readRecord, readString, semanticHash, semanticMetadata, semanticSlug, sourceSemanticText, splitSentences, uniqueStrings, } from './utils.js';
+export async function promoteRepairSources(context, spaceId, gap, sourceIds, task, deadlineAt) {
+    if (context.enrichSource) {
+        for (const [index, sourceId] of sourceIds.entries()) {
+            await yieldEvery(index, 2);
+            const remainingMs = Math.max(0, deadlineAt - Date.now());
+            if (remainingMs < 1_000)
+                break;
+            await withTimeout(context.enrichSource(sourceId, { knowledgeSpaceId: spaceId, force: true }), Math.min(remainingMs, 20_000), 'Semantic repair source enrichment exceeded its run budget.');
+            await yieldToEventLoop();
+        }
+    }
+    const promotedFactCount = await promoteRepairEvidenceFacts(context.store, spaceId, gap, sourceIds);
+    await linkPromotedFactsToRepairSubjects(context.store, spaceId, gap, sourceIds);
+    await updateRefinementTask(context.store, context.store.getRefinementTask(task.id) ?? task, 'verified', 'Accepted repair sources were semantically enriched.', {
+        promotedSourceIds: sourceIds,
+        promotedFactCount,
+    });
+}
+async function promoteRepairEvidenceFacts(store, spaceId, gap, sourceIds) {
+    const subjects = linkedRepairSubjects(store, spaceId, gap);
+    if (subjects.length === 0)
+        return 0;
+    let promoted = 0;
+    for (const sourceId of sourceIds) {
+        const source = store.getSource(sourceId);
+        if (!source)
+            continue;
+        const extraction = store.getExtractionBySourceId(source.id);
+        const authority = sourceAuthority(source);
+        const sentences = selectRepairFactSentences({
+            query: gap.title,
+            source,
+            text: sourceSemanticText(source, extraction),
+        });
+        for (const [index, sentence] of sentences.entries()) {
+            const classification = classifyRepairFact(sentence);
+            const fact = await store.upsertNode({
+                id: `sem-fact-${semanticHash(spaceId, source.id, gap.id, classification.title, sentence)}`,
+                kind: 'fact',
+                slug: semanticSlug(`${spaceId}-${classification.title}-${source.id}-${index}`),
+                title: classification.title,
+                summary: sentence,
+                aliases: classification.aliases,
+                status: 'active',
+                confidence: authority === 'official-vendor' ? 88 : 76,
+                sourceId: source.id,
+                metadata: semanticMetadata(spaceId, {
+                    semanticKind: 'fact',
+                    factKind: classification.kind,
+                    value: classification.value,
+                    evidence: sentence,
+                    labels: classification.labels,
+                    sourceId: source.id,
+                    gapId: gap.id,
+                    linkedObjectIds: subjects.map((subject) => subject.id),
+                    extractor: 'repair-promotion',
+                    sourceAuthority: authority,
+                    sourceDiscovery: readRecord(source.metadata.sourceDiscovery),
+                }),
+            });
+            await store.upsertEdge({
+                fromKind: 'source',
+                fromId: source.id,
+                toKind: 'node',
+                toId: fact.id,
+                relation: 'supports_fact',
+                weight: authority === 'official-vendor' ? 0.95 : 0.84,
+                metadata: semanticMetadata(spaceId, {
+                    linkedBy: 'semantic-gap-repair',
+                    gapId: gap.id,
+                }),
+            });
+            for (const subject of subjects) {
+                await store.upsertEdge({
+                    fromKind: 'node',
+                    fromId: fact.id,
+                    toKind: 'node',
+                    toId: subject.id,
+                    relation: 'describes',
+                    weight: authority === 'official-vendor' ? 0.94 : 0.82,
+                    metadata: semanticMetadata(spaceId, {
+                        linkedBy: 'semantic-gap-repair',
+                        repairedAt: Date.now(),
+                        sourceId: source.id,
+                        gapId: gap.id,
+                    }),
+                });
+            }
+            promoted += 1;
+        }
+    }
+    return promoted;
+}
+async function linkPromotedFactsToRepairSubjects(store, spaceId, gap, sourceIds) {
+    const linkedObjectIds = readStringArray(gap.metadata.linkedObjectIds).filter((nodeId) => Boolean(store.getNode(nodeId)));
+    if (linkedObjectIds.length === 0)
+        return;
+    const edges = store.listEdges();
+    const nodesById = new Map(store.listNodes(10_000).filter((node) => getKnowledgeSpaceId(node) === spaceId).map((node) => [node.id, node]));
+    for (const sourceId of sourceIds) {
+        for (const fact of factsForSource(sourceId, edges, nodesById)) {
+            for (const objectId of linkedObjectIds) {
+                await store.upsertEdge({
+                    fromKind: 'node',
+                    fromId: fact.id,
+                    toKind: 'node',
+                    toId: objectId,
+                    relation: 'describes',
+                    weight: 0.82,
+                    metadata: semanticMetadata(spaceId, {
+                        linkedBy: 'semantic-gap-repair',
+                        repairedAt: Date.now(),
+                        sourceId,
+                    }),
+                });
+            }
+        }
+    }
+}
+function selectRepairFactSentences(input) {
+    const wanted = repairIntentPatterns(input.query);
+    const sourceText = normalizeWhitespace(input.text);
+    const candidates = splitSentences(sourceText, 360)
+        .map((sentence) => normalizeWhitespace(sentence))
+        .filter((sentence) => sentence.length >= 24 && sentence.length <= 360)
+        .filter((sentence) => !sentence.trim().endsWith('?'))
+        .filter((sentence) => hasConcreteFeatureSignal(sentence))
+        .filter((sentence) => !isLowValueFeatureOrSpecText(sentence));
+    const scored = candidates.map((sentence) => ({
+        sentence,
+        score: repairSentenceScore(sentence, wanted, input.source),
+    })).filter((entry) => entry.score > 0);
+    return uniqueStrings(scored
+        .sort((left, right) => right.score - left.score || left.sentence.localeCompare(right.sentence))
+        .map((entry) => entry.sentence))
+        .slice(0, 14);
+}
+function repairSentenceScore(sentence, wanted, source) {
+    const lower = sentence.toLowerCase();
+    let score = sourceAuthority(source) === 'official-vendor' ? 12 : 0;
+    if (wanted.some((pattern) => pattern.test(lower)))
+        score += 20;
+    if (hasConcreteFeatureSignal(lower))
+        score += 8;
+    if (/\b(hdmi|usb|ethernet|wi-?fi|bluetooth|hdr|dolby|resolution|refresh|120\s*hz|speaker|tuner|atsc|qam|webos|airplay|homekit|freesync|vrr|allm|earc|arc)\b/.test(lower)) {
+        score += 12;
+    }
+    if (/\b(specifications?|features?|connectivity|ports?|display|audio|network|smart tv|gaming)\b/.test(lower))
+        score += 6;
+    if (/^\s*\d+\s/.test(lower) || /\b(question|answer|faq|click|price|review|manual\.nz)\b/.test(lower))
+        score -= 20;
+    return score;
+}
+function classifyRepairFact(sentence) {
+    const lower = sentence.toLowerCase();
+    if (/\b(resolution|4k|8k|uhd|display|screen|nanocell|lcd|oled|qled|refresh|hz|hdr|dolby vision|hlg)\b/.test(lower)) {
+        return { kind: 'specification', title: 'Display and picture specifications', labels: ['display', 'picture'], aliases: ['display', 'picture'] };
+    }
+    if (/\b(hdmi|usb|ethernet|optical|rf|antenna|rs-?232|composite|component|earc|arc|ports?|input|output)\b/.test(lower)) {
+        return { kind: 'specification', title: 'Input and output ports', labels: ['ports', 'connectivity'], aliases: ['ports', 'inputs', 'outputs'] };
+    }
+    if (/\b(wi-?fi|bluetooth|wireless|airplay|homekit|miracast|chromecast|ethernet)\b/.test(lower)) {
+        return { kind: 'capability', title: 'Network and wireless capabilities', labels: ['network', 'wireless'], aliases: ['network', 'wireless'] };
+    }
+    if (/\b(speaker|audio|dolby atmos|dolby audio|sound|watts?|channels?)\b/.test(lower)) {
+        return { kind: 'specification', title: 'Audio capabilities', labels: ['audio'], aliases: ['audio', 'speakers'] };
+    }
+    if (/\b(game|gaming|vrr|allm|freesync|g-?sync|low latency)\b/.test(lower)) {
+        return { kind: 'feature', title: 'Gaming features', labels: ['gaming'], aliases: ['gaming'] };
+    }
+    if (/\b(webos|smart tv|apps?|voice assistant|alexa|google assistant|streaming)\b/.test(lower)) {
+        return { kind: 'feature', title: 'Smart TV features', labels: ['smart-tv'], aliases: ['smart tv', 'apps'] };
+    }
+    if (/\b(tuner|atsc|ntsc|qam|broadcast|clear qam)\b/.test(lower)) {
+        return { kind: 'specification', title: 'Tuner support', labels: ['tuner'], aliases: ['tuner', 'broadcast'] };
+    }
+    return {
+        kind: 'feature',
+        title: clampText(sentence, 80),
+        labels: ['source-backed'],
+        aliases: [],
+    };
+}
+function repairIntentPatterns(query) {
+    const lower = query.toLowerCase();
+    const patterns = [];
+    if (/\b(port|ports|input|output|hdmi|usb|optical|rf|antenna|rs-?232|composite|component|i\/o)\b/.test(lower))
+        patterns.push(/\b(hdmi|usb|optical|rf|antenna|ethernet|rs-?232|composite|component|earc|arc|ports?|input|output)\b/);
+    if (/\b(bluetooth|wifi|wi-fi|wireless|network)\b/.test(lower))
+        patterns.push(/\b(bluetooth|wi-?fi|wireless|network|ethernet|airplay|homekit)\b/);
+    if (/\b(refresh|hz|hdr|dolby|vision|gaming|vrr|allm|freesync)\b/.test(lower))
+        patterns.push(/\b(refresh|hz|hdr|hdr10|dolby vision|hlg|game|vrr|allm|freesync|120\s*hz|100\s*hz)\b/);
+    if (/\b(display|screen|resolution|panel|nanocell|lcd|oled)\b/.test(lower))
+        patterns.push(/\b(display|screen|resolution|4k|uhd|nanocell|lcd|oled|panel)\b/);
+    if (patterns.length === 0)
+        patterns.push(/\b(hdmi|usb|hdr|dolby|resolution|refresh|wi-?fi|bluetooth|speaker|audio|webos|smart tv|tuner|gaming|ports?)\b/);
+    return patterns;
+}
+function linkedRepairSubjects(store, spaceId, gap) {
+    return uniqueById(readStringArray(gap.metadata.linkedObjectIds)
+        .map((id) => store.getNode(id))
+        .filter((node) => Boolean(node))
+        .filter((node) => getKnowledgeSpaceId(node) === spaceId && node.status !== 'stale'));
+}
+function factsForSource(sourceId, edges, nodesById) {
+    return uniqueById(edges
+        .filter((edge) => edge.fromKind === 'source' && edge.fromId === sourceId && edge.toKind === 'node')
+        .map((edge) => nodesById.get(edge.toId))
+        .filter((node) => Boolean(node))
+        .filter((node) => node.kind === 'fact' && node.status !== 'stale'));
+}
+function sourceAuthority(source) {
+    const discovery = readRecord(source.metadata.sourceDiscovery);
+    const trust = `${readString(discovery.trustReason) ?? ''} ${readString(discovery.sourceDomain) ?? ''} ${source.sourceUri ?? ''} ${source.canonicalUri ?? ''}`.toLowerCase();
+    if (/\bofficial-vendor-domain\b/.test(trust) || /(^|[/.])lg\.com\b|(^|[/.])sony\.com\b|(^|[/.])samsung\.com\b|(^|[/.])apple\.com\b/.test(trust)) {
+        return 'official-vendor';
+    }
+    if (/\bmanufacturer-domain\b/.test(trust))
+        return 'vendor';
+    return 'secondary';
+}
+function uniqueById(items) {
+    const seen = new Set();
+    const result = [];
+    for (const item of items) {
+        if (!item || seen.has(item.id))
+            continue;
+        seen.add(item.id);
+        result.push(item);
+    }
+    return result;
+}
+function readStringArray(value) {
+    if (!Array.isArray(value))
+        return [];
+    return uniqueStrings(value.map((entry) => typeof entry === 'string' ? entry : undefined));
+}

package/dist/_internal/platform/knowledge/semantic/self-improvement-tasks.d.ts

@@ -0,0 +1,12 @@
+import type { KnowledgeNodeRecord, KnowledgeRefinementTaskRecord, KnowledgeRefinementTaskState, KnowledgeRefinementTaskTrigger } from '../types.js';
+import type { KnowledgeStore } from '../store.js';
+export interface RefinementTaskGapContext {
+    readonly gap: KnowledgeNodeRecord;
+    readonly sources: readonly {
+        readonly id: string;
+    }[];
+    readonly linkedObjects: readonly KnowledgeNodeRecord[];
+}
+export declare function upsertRefinementTaskForGap(store: KnowledgeStore, spaceId: string, context: RefinementTaskGapContext, trigger: KnowledgeRefinementTaskTrigger, state: KnowledgeRefinementTaskState, message: string, data?: Record<string, unknown>): Promise<KnowledgeRefinementTaskRecord>;
+export declare function updateRefinementTask(store: KnowledgeStore, task: KnowledgeRefinementTaskRecord, state: KnowledgeRefinementTaskState, message: string, data?: Record<string, unknown>): Promise<KnowledgeRefinementTaskRecord>;
+//# sourceMappingURL=self-improvement-tasks.d.ts.map

package/dist/_internal/platform/knowledge/semantic/self-improvement-tasks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"self-improvement-tasks.d.ts","sourceRoot":"","sources":["../../../../../src/_internal/platform/knowledge/semantic/self-improvement-tasks.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,mBAAmB,EACnB,6BAA6B,EAC7B,4BAA4B,EAC5B,8BAA8B,EAC/B,MAAM,aAAa,CAAC;AACrB,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAGlD,MAAM,WAAW,wBAAwB;IACvC,QAAQ,CAAC,GAAG,EAAE,mBAAmB,CAAC;IAClC,QAAQ,CAAC,OAAO,EAAE,SAAS;QAAE,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC;IACrD,QAAQ,CAAC,aAAa,EAAE,SAAS,mBAAmB,EAAE,CAAC;CACxD;AAED,wBAAsB,0BAA0B,CAC9C,KAAK,EAAE,cAAc,EACrB,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,wBAAwB,EACjC,OAAO,EAAE,8BAA8B,EACvC,KAAK,EAAE,4BAA4B,EACnC,OAAO,EAAE,MAAM,EACf,IAAI,GAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAM,GACjC,OAAO,CAAC,6BAA6B,CAAC,CAiCxC;AAED,wBAAsB,oBAAoB,CACxC,KAAK,EAAE,cAAc,EACrB,IAAI,EAAE,6BAA6B,EACnC,KAAK,EAAE,4BAA4B,EACnC,OAAO,EAAE,MAAM,EACf,IAAI,GAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAM,GACjC,OAAO,CAAC,6BAA6B,CAAC,CAwBxC"}

package/dist/_internal/platform/knowledge/semantic/self-improvement-tasks.js

@@ -0,0 +1,87 @@
+import { readString, semanticHash, semanticMetadata } from './utils.js';
+export async function upsertRefinementTaskForGap(store, spaceId, context, trigger, state, message, data = {}) {
+    const subject = context.linkedObjects[0];
+    const id = `kref-${semanticHash(spaceId, context.gap.id, subject?.id ?? 'unscoped')}`;
+    const existing = store.getRefinementTask(id);
+    const attemptCount = existing?.attemptCount ?? 0;
+    return store.upsertRefinementTask({
+        id,
+        spaceId,
+        ...(subject ? {
+            subjectKind: 'node',
+            subjectId: subject.id,
+            subjectTitle: subjectTitle(subject),
+            subjectType: subject.kind,
+        } : {}),
+        gapId: context.gap.id,
+        state,
+        trigger,
+        priority: refinementPriority(context.gap),
+        budget: {
+            maxSearches: 5,
+            maxSources: 5,
+            maxLlmCalls: 1,
+        },
+        attemptCount,
+        appendTrace: [trace(state, message, data)],
+        metadata: semanticMetadata(spaceId, {
+            gapTitle: context.gap.title,
+            gapKind: readString(context.gap.metadata.gapKind) ?? 'unknown',
+            sourceIds: context.sources.map((source) => source.id),
+            linkedObjectIds: context.linkedObjects.map((node) => node.id),
+            policyVersion: 'knowledge-refinement-v1',
+        }),
+    });
+}
+export async function updateRefinementTask(store, task, state, message, data = {}) {
+    const nextRepairAttemptAt = readNumber(data.nextRepairAttemptAt) ?? task.nextRepairAttemptAt;
+    return store.upsertRefinementTask({
+        id: task.id,
+        spaceId: task.spaceId,
+        subjectKind: task.subjectKind,
+        subjectId: task.subjectId,
+        subjectTitle: task.subjectTitle,
+        subjectType: task.subjectType,
+        gapId: task.gapId,
+        issueId: task.issueId,
+        state,
+        priority: task.priority,
+        trigger: task.trigger,
+        budget: task.budget,
+        attemptCount: state === 'searching' ? task.attemptCount + 1 : task.attemptCount,
+        ...(state === 'blocked' || state === 'failed' ? { blockedReason: message } : {}),
+        ...(typeof nextRepairAttemptAt === 'number' ? { nextRepairAttemptAt } : {}),
+        appendTrace: [trace(state, message, data)],
+        metadata: {
+            ...task.metadata,
+            ...(typeof nextRepairAttemptAt === 'number' ? { nextRepairAttemptAt } : {}),
+        },
+    });
+}
+function trace(state, message, data = {}) {
+    return {
+        at: Date.now(),
+        state,
+        message,
+        ...(Object.keys(data).length > 0 ? { data } : {}),
+    };
+}
+function refinementPriority(gap) {
+    const severity = readString(gap.metadata.severity);
+    const kind = readString(gap.metadata.gapKind);
+    if (severity === 'error')
+        return 'urgent';
+    if (severity === 'warning' || kind === 'intrinsic_features')
+        return 'high';
+    return 'normal';
+}
+function subjectTitle(subject) {
+    return [
+        readString(subject.metadata.manufacturer),
+        readString(subject.metadata.model),
+        subject.title,
+    ].filter(Boolean).join(' ');
+}
+function readNumber(value) {
+    return typeof value === 'number' && Number.isFinite(value) ? value : undefined;
+}