@pellux/goodvibes-sdk 0.28.16 → 0.28.18

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

@@ -0,0 +1,152 @@
+import { hasConcreteFeatureSignal, isLowValueFeatureOrSpecText } from './fact-quality.js';
+import { clampText, normalizeWhitespace, uniqueStrings } from './utils.js';
+const PROFILE_RULES = [
+    {
+        title: 'Display and picture specifications',
+        kind: 'specification',
+        labels: ['display', 'picture'],
+        aliases: ['display', 'picture', 'screen'],
+        intent: /\b(display|screen|resolution|picture|panel|hdr|refresh|hz|dolby vision|nanocell|lcd|led|oled)\b/,
+        minimumMatches: 2,
+        terms: [
+            ['86-inch class screen', /\b86(?:\.0)?\s*(?:inch|inches|in\.|")\b|\b86nano/i],
+            ['4K UHD resolution', /\b4k\b|\buhd\b|\b3840\s*(?:x|×)\s*2160\b/i],
+            ['NanoCell display technology', /\bnanocell\b/i],
+            ['LCD/LED display', /\blcd\b|\bled\b/i],
+            ['100/120 Hz refresh-rate evidence', /\b(?:100|120)\s*hz\b|\btrumotion\s*240\b/i],
+            ['HDR10', /\bhdr10\b/i],
+            ['Dolby Vision', /\bdolby vision\b/i],
+            ['HLG', /\bhlg\b/i],
+        ],
+    },
+    {
+        title: 'Input and output ports',
+        kind: 'specification',
+        labels: ['ports', 'connectivity'],
+        aliases: ['ports', 'inputs', 'outputs', 'connectivity'],
+        intent: /\b(port|ports|input|output|i\/o|hdmi|usb|optical|rf|antenna|ethernet|rs-?232|composite|component|earc|arc)\b/,
+        minimumMatches: 2,
+        terms: [
+            ['HDMI inputs', /\bhdmi\b/i],
+            ['HDMI ARC/eARC', /\bearc\b|\barc\b/i],
+            ['USB ports', /\busb\b/i],
+            ['Ethernet', /\bethernet\b|\brj-?45\b/i],
+            ['Optical audio output', /\boptical\b|\btoslink\b/i],
+            ['RF antenna input', /\brf\b|\bantenna\b/i],
+            ['Composite/component video', /\bcomposite\b|\bcomponent\b/i],
+            ['RS-232C/external control', /\brs-?232c?\b|\bexternal control\b/i],
+        ],
+    },
+    {
+        title: 'Smart TV platform and integrations',
+        kind: 'feature',
+        labels: ['smart-tv', 'apps'],
+        aliases: ['smart tv', 'apps', 'platform'],
+        intent: /\b(smart|webos|apps?|streaming|airplay|homekit|thinq|voice|assistant|alexa|google assistant)\b/,
+        minimumMatches: 1,
+        terms: [
+            ['webOS smart TV platform', /\bwebos\b/i],
+            ['LG ThinQ AI', /\bthinq\b/i],
+            ['Apple AirPlay 2', /\bairplay\s*2?\b/i],
+            ['Apple HomeKit', /\bhomekit\b/i],
+            ['voice assistant support', /\bvoice\b|\balexa\b|\bgoogle assistant\b/i],
+            ['streaming app support', /\bapps?\b|\bstreaming\b/i],
+        ],
+    },
+    {
+        title: 'Network and wireless capabilities',
+        kind: 'capability',
+        labels: ['network', 'wireless'],
+        aliases: ['network', 'wireless', 'bluetooth', 'wi-fi'],
+        intent: /\b(wi-?fi|wireless|bluetooth|ethernet|network|lan)\b/,
+        minimumMatches: 1,
+        terms: [
+            ['Wi-Fi/wireless LAN', /\bwi-?fi\b|\bwireless lan\b/i],
+            ['Bluetooth', /\bbluetooth\b/i],
+            ['Ethernet/LAN', /\bethernet\b|\blan\b/i],
+        ],
+    },
+    {
+        title: 'Gaming and HDMI features',
+        kind: 'feature',
+        labels: ['gaming', 'hdmi'],
+        aliases: ['gaming', 'game mode', 'hdmi 2.1'],
+        intent: /\b(game|gaming|vrr|allm|freesync|g-?sync|low latency|hdmi\s*2\.1|4k\s*120)\b/,
+        minimumMatches: 1,
+        terms: [
+            ['FreeSync/VRR evidence', /\bfreesync\b|\bvrr\b/i],
+            ['ALLM/low latency evidence', /\ballm\b|\blow latency\b/i],
+            ['Game Optimizer/game mode', /\bgame optimizer\b|\bgame mode\b|\bgaming\b/i],
+            ['HDMI 2.1/high-bandwidth HDMI evidence', /\bhdmi\s*2\.1\b|\b4k\s*(?:at|@)?\s*120\b|\b120\s*hz\b/i],
+        ],
+    },
+    {
+        title: 'Audio capabilities',
+        kind: 'specification',
+        labels: ['audio'],
+        aliases: ['audio', 'speakers', 'sound'],
+        intent: /\b(audio|speaker|sound|dolby atmos|dolby digital|earc|arc|watts?|channels?)\b/,
+        minimumMatches: 1,
+        terms: [
+            ['speaker/audio output evidence', /\bspeakers?\b|\b(?:10|20|40)\s*w\b|\b2(?:\.0)?\s*ch\b/i],
+            ['Dolby audio formats', /\bdolby atmos\b|\bdolby digital\b|\bdolby audio\b/i],
+            ['HDMI ARC/eARC audio', /\bearc\b|\barc\b/i],
+            ['supported audio formats', /\bsupported audio formats?\b|\bpcm\b|\btruehd\b/i],
+        ],
+    },
+    {
+        title: 'Tuner and broadcast support',
+        kind: 'specification',
+        labels: ['tuner', 'broadcast'],
+        aliases: ['tuner', 'broadcast', 'antenna'],
+        intent: /\b(tuner|atsc|ntsc|qam|broadcast|clear qam|antenna)\b/,
+        minimumMatches: 1,
+        terms: [
+            ['ATSC tuner support', /\batsc\b/i],
+            ['NTSC analog tuner support', /\bntsc\b/i],
+            ['Clear QAM support', /\bqam\b|\bclear qam\b/i],
+            ['RF/antenna input', /\brf\b|\bantenna\b/i],
+        ],
+    },
+];
+export function deriveRepairProfileFacts(input) {
+    const text = normalizeWhitespace([
+        input.source.title,
+        input.source.summary,
+        input.source.description,
+        input.source.sourceUri,
+        input.source.canonicalUri,
+        input.text,
+    ].filter(Boolean).join(' '));
+    if (!hasConcreteFeatureSignal(text))
+        return [];
+    const query = input.query.toLowerCase();
+    const broadProfileIntent = /\b(features?|specifications?|profile|capabilities)\b/.test(query);
+    return PROFILE_RULES.flatMap((rule) => {
+        const values = uniqueStrings(rule.terms
+            .filter(([, pattern]) => pattern.test(text))
+            .map(([label]) => label));
+        const wanted = broadProfileIntent || rule.intent.test(query);
+        if (values.length < (wanted ? 1 : rule.minimumMatches))
+            return [];
+        const summary = `${rule.title} evidence includes ${joinValues(values)}.`;
+        if (isLowValueFeatureOrSpecText(summary))
+            return [];
+        return [{
+                kind: rule.kind,
+                title: rule.title,
+                value: values.join(', '),
+                summary,
+                evidence: clampText(summary, 360),
+                labels: rule.labels,
+                aliases: rule.aliases,
+            }];
+    }).slice(0, 10);
+}
+function joinValues(values) {
+    if (values.length <= 1)
+        return values[0] ?? '';
+    if (values.length === 2)
+        return `${values[0]} and ${values[1]}`;
+    return `${values.slice(0, -1).join(', ')}, and ${values[values.length - 1]}`;
+}

package/dist/_internal/platform/knowledge/semantic/repair-subjects.d.ts

@@ -0,0 +1,16 @@
+import type { KnowledgeNodeRecord } from '../types.js';
+export interface RepairSubjectHint {
+    readonly id: string;
+    readonly kind: string;
+    readonly title: string;
+}
+export declare function canonicalRepairSubjectNodes(input: {
+    readonly nodes: readonly (KnowledgeNodeRecord | undefined)[];
+    readonly text?: string;
+}): KnowledgeNodeRecord[];
+export declare function repairSubjectIds(input: {
+    readonly nodes: readonly (KnowledgeNodeRecord | undefined)[];
+    readonly text?: string;
+}): string[];
+export declare function repairSubjectHints(subjects: readonly KnowledgeNodeRecord[]): RepairSubjectHint[];
+//# sourceMappingURL=repair-subjects.d.ts.map

package/dist/_internal/platform/knowledge/semantic/repair-subjects.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"repair-subjects.d.ts","sourceRoot":"","sources":["../../../../../src/_internal/platform/knowledge/semantic/repair-subjects.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAC;AAGvD,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;CACxB;AAED,wBAAgB,2BAA2B,CAAC,KAAK,EAAE;IACjD,QAAQ,CAAC,KAAK,EAAE,SAAS,CAAC,mBAAmB,GAAG,SAAS,CAAC,EAAE,CAAC;IAC7D,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;CACxB,GAAG,mBAAmB,EAAE,CAgBxB;AAED,wBAAgB,gBAAgB,CAAC,KAAK,EAAE;IACtC,QAAQ,CAAC,KAAK,EAAE,SAAS,CAAC,mBAAmB,GAAG,SAAS,CAAC,EAAE,CAAC;IAC7D,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;CACxB,GAAG,MAAM,EAAE,CAEX;AAED,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,SAAS,mBAAmB,EAAE,GAAG,iBAAiB,EAAE,CAMhG"}

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

@@ -0,0 +1,52 @@
+import { readString } from './utils.js';
+export function canonicalRepairSubjectNodes(input) {
+    const usable = uniqueNodes(input.nodes)
+        .filter((node) => node.status !== 'stale')
+        .filter((node) => !readString(node.metadata.semanticKind))
+        .filter((node) => !['fact', 'wiki_page', 'knowledge_gap', 'ha_device_passport'].includes(node.kind));
+    const devices = usable.filter((node) => node.kind === 'ha_device');
+    if (devices.length > 0)
+        return devices;
+    const entities = usable.filter((node) => node.kind === 'ha_entity');
+    if (entities.length > 0)
+        return entities;
+    const concreteKnowledge = usable.filter((node) => node.kind === 'knowledge_entity' && hasConcreteProductIdentity(node));
+    if (concreteKnowledge.length > 0)
+        return concreteKnowledge;
+    const nonIntegration = usable.filter((node) => node.kind !== 'ha_integration');
+    if (nonIntegration.length > 0)
+        return nonIntegration;
+    const integrationIntent = /\b(integration|platform|add-?on|addon|plugin|service|api|setup|configure|configuration|auth|credential|rate limit)\b/i.test(input.text ?? '');
+    const integrations = usable.filter((node) => node.kind === 'ha_integration');
+    return integrationIntent ? integrations : [];
+}
+export function repairSubjectIds(input) {
+    return canonicalRepairSubjectNodes(input).map((node) => node.id);
+}
+export function repairSubjectHints(subjects) {
+    return subjects.map((subject) => ({
+        id: subject.id,
+        kind: subject.kind,
+        title: subject.title,
+    }));
+}
+function hasConcreteProductIdentity(node) {
+    const entityKind = readString(node.metadata.entityKind)?.toLowerCase() ?? '';
+    if (/\b(device|product|appliance|controller|hardware|phone|tv|printer|router|sensor|hub|bridge)\b/.test(entityKind))
+        return true;
+    if (readString(node.metadata.model))
+        return true;
+    const text = `${node.title} ${node.summary ?? ''} ${node.aliases.join(' ')}`;
+    return /\b[A-Z]{2,}[-_ ]?[0-9][A-Z0-9._-]{2,}\b/.test(text);
+}
+function uniqueNodes(nodes) {
+    const seen = new Set();
+    const result = [];
+    for (const node of nodes) {
+        if (!node || seen.has(node.id))
+            continue;
+        seen.add(node.id);
+        result.push(node);
+    }
+    return result;
+}

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

@@ -1 +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,MAAM,CAAC,CAwBjB"}
+{"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;AAmBrB,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,MAAM,CAAC,CAwBjB"}

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

@@ -1,8 +1,10 @@
 import { yieldEvery, yieldToEventLoop } from '../cooperative.js';
 import { getKnowledgeSpaceId } from '../spaces.js';
 import { hasConcreteFeatureSignal, isLowValueFeatureOrSpecText } from './fact-quality.js';
+import { deriveRepairProfileFacts } from './repair-profile.js';
 import { updateRefinementTask } from './self-improvement-tasks.js';
 import { withTimeout } from './timeouts.js';
+import { canonicalRepairSubjectNodes, repairSubjectHints } from './repair-subjects.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) {
@@ -37,74 +39,112 @@ async function promoteRepairEvidenceFacts(store, spaceId, gap, sourceIds) {
             continue;
         const extraction = store.getExtractionBySourceId(source.id);
         const authority = sourceAuthority(source);
+        const text = sourceSemanticText(source, extraction);
+        const profileFacts = deriveRepairProfileFacts({
+            query: gap.title,
+            source,
+            text,
+        });
+        for (const profileFact of profileFacts) {
+            promoted += await upsertPromotedRepairFact({
+                store,
+                spaceId,
+                gap,
+                source,
+                subjects,
+                authority,
+                title: profileFact.title,
+                summary: profileFact.summary,
+                classification: profileFact,
+                evidence: profileFact.evidence,
+            });
+        }
         const sentences = selectRepairFactSentences({
             query: gap.title,
             source,
-            text: sourceSemanticText(source, extraction),
+            text,
         });
-        for (const [index, sentence] of sentences.entries()) {
+        for (const sentence of sentences) {
             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}`),
+            promoted += await upsertPromotedRepairFact({
+                store,
+                spaceId,
+                gap,
+                source,
+                subjects,
+                authority,
                 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,
-                }),
+                classification,
+                evidence: sentence,
             });
-            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 upsertPromotedRepairFact(input) {
+    const fact = await input.store.upsertNode({
+        id: `sem-fact-${semanticHash(input.spaceId, input.source.id, input.gap.id, input.title, input.summary)}`,
+        kind: 'fact',
+        slug: semanticSlug(`${input.spaceId}-${input.title}-${input.source.id}`),
+        title: input.title,
+        summary: input.summary,
+        aliases: input.classification.aliases,
+        status: 'active',
+        confidence: input.authority === 'official-vendor' ? 90 : input.authority === 'vendor' ? 82 : 76,
+        sourceId: input.source.id,
+        metadata: semanticMetadata(input.spaceId, {
+            semanticKind: 'fact',
+            factKind: input.classification.kind,
+            value: input.classification.value,
+            evidence: input.evidence,
+            labels: input.classification.labels,
+            sourceId: input.source.id,
+            gapId: input.gap.id,
+            subject: input.subjects[0]?.title,
+            subjectIds: input.subjects.map((subject) => subject.id),
+            targetHints: repairSubjectHints(input.subjects),
+            linkedObjectIds: input.subjects.map((subject) => subject.id),
+            extractor: 'repair-promotion',
+            sourceAuthority: input.authority,
+            sourceDiscovery: readRecord(input.source.metadata.sourceDiscovery),
+        }),
+    });
+    await input.store.upsertEdge({
+        fromKind: 'source',
+        fromId: input.source.id,
+        toKind: 'node',
+        toId: fact.id,
+        relation: 'supports_fact',
+        weight: input.authority === 'official-vendor' ? 0.96 : 0.84,
+        metadata: semanticMetadata(input.spaceId, {
+            linkedBy: 'semantic-gap-repair',
+            gapId: input.gap.id,
+        }),
+    });
+    for (const subject of input.subjects) {
+        await input.store.upsertEdge({
+            fromKind: 'node',
+            fromId: fact.id,
+            toKind: 'node',
+            toId: subject.id,
+            relation: 'describes',
+            weight: input.authority === 'official-vendor' ? 0.95 : 0.82,
+            metadata: semanticMetadata(input.spaceId, {
+                linkedBy: 'semantic-gap-repair',
+                repairedAt: Date.now(),
+                sourceId: input.source.id,
+                gapId: input.gap.id,
+            }),
+        });
+    }
+    return 1;
+}
 async function linkPromotedFactsToRepairSubjects(store, spaceId, gap, sourceIds) {
-    const linkedObjectIds = readStringArray(gap.metadata.linkedObjectIds).filter((nodeId) => Boolean(store.getNode(nodeId)));
-    if (linkedObjectIds.length === 0)
+    const subjects = linkedRepairSubjects(store, spaceId, gap);
+    if (subjects.length === 0)
         return;
+    const linkedObjectIds = subjects.map((subject) => subject.id);
     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) {
@@ -207,10 +247,35 @@ function repairIntentPatterns(query) {
     return patterns;
 }
 function linkedRepairSubjects(store, spaceId, gap) {
-    return uniqueById(readStringArray(gap.metadata.linkedObjectIds)
-        .map((id) => store.getNode(id))
+    const edges = store.listEdges();
+    const nodesById = new Map(store.listNodes(10_000)
+        .filter((node) => getKnowledgeSpaceId(node) === spaceId)
+        .map((node) => [node.id, node]));
+    const sourceIds = uniqueStrings([
+        gap.sourceId,
+        ...readStringArray(gap.metadata.sourceIds),
+        ...edges
+            .filter((edge) => edge.toKind === 'node' && edge.toId === gap.id && edge.fromKind === 'source')
+            .map((edge) => edge.fromId),
+    ]);
+    return canonicalRepairSubjectNodes({
+        text: `${gap.title} ${gap.summary ?? ''}`,
+        nodes: [
+            ...readStringArray(gap.metadata.linkedObjectIds).map((id) => nodesById.get(id)),
+            ...edges
+                .filter((edge) => edge.fromKind === 'node' && edge.toKind === 'node' && edge.toId === gap.id)
+                .map((edge) => nodesById.get(edge.fromId)),
+            ...sourceIds.flatMap((sourceId) => linkedObjectsForSource(sourceId, edges, nodesById)),
+        ],
+    });
+}
+function linkedObjectsForSource(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) => getKnowledgeSpaceId(node) === spaceId && node.status !== 'stale'));
+        .filter((node) => node.status !== 'stale')
+        .filter((node) => node.metadata.semanticKind !== 'fact' && node.metadata.semanticKind !== 'gap' && node.kind !== 'wiki_page'));
 }
 function factsForSource(sourceId, edges, nodesById) {
     return uniqueById(edges

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

@@ -1 +1 @@
-{"version":3,"file":"self-improvement.d.ts","sourceRoot":"","sources":["../../../../../src/_internal/platform/knowledge/semantic/self-improvement.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAOlD,OAAO,KAAK,EACV,4BAA4B,EAC5B,iCAAiC,EACjC,kCAAkC,EACnC,MAAM,YAAY,CAAC;AAapB,UAAU,kBAAkB;IAC1B,QAAQ,CAAC,KAAK,EAAE,cAAc,CAAC;IAC/B,QAAQ,CAAC,WAAW,CAAC,EAAE,4BAA4B,GAAG,IAAI,CAAC;IAC3D,QAAQ,CAAC,gBAAgB,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IACvC,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;AAUD,wBAAsB,mCAAmC,CACvD,OAAO,EAAE,kBAAkB,EAC3B,KAAK,GAAE,iCAAsC,GAC5C,OAAO,CAAC,kCAAkC,CAAC,CA8N7C"}
+{"version":3,"file":"self-improvement.d.ts","sourceRoot":"","sources":["../../../../../src/_internal/platform/knowledge/semantic/self-improvement.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAOlD,OAAO,KAAK,EACV,4BAA4B,EAC5B,iCAAiC,EACjC,kCAAkC,EACnC,MAAM,YAAY,CAAC;AAcpB,UAAU,kBAAkB;IAC1B,QAAQ,CAAC,KAAK,EAAE,cAAc,CAAC;IAC/B,QAAQ,CAAC,WAAW,CAAC,EAAE,4BAA4B,GAAG,IAAI,CAAC;IAC3D,QAAQ,CAAC,gBAAgB,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IACvC,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;AAUD,wBAAsB,mCAAmC,CACvD,OAAO,EAAE,kBAAkB,EAC3B,KAAK,GAAE,iCAAsC,GAC5C,OAAO,CAAC,kCAAkC,CAAC,CA+N7C"}

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

@@ -6,6 +6,7 @@ import { readRecord, readString, semanticHash, semanticMetadata, semanticSlug, s
 import { withTimeout } from './timeouts.js';
 import { updateRefinementTask, upsertRefinementTaskForGap } from './self-improvement-tasks.js';
 import { promoteRepairSources } from './self-improvement-promotion.js';
+import { canonicalRepairSubjectNodes, repairSubjectIds } from './repair-subjects.js';
 const RETRY_DELAY_MS = 6 * 60 * 60 * 1000;
 const DEFAULT_REFINEMENT_LIMIT = 12;
 const MAX_REFINEMENT_LIMIT = 24;
@@ -23,11 +24,12 @@ export async function runKnowledgeSemanticSelfImprovement(context, input = {}) {
     const createdGaps = await discoverIntrinsicGaps(context.store, spaceId, sourceIdFilter);
     const candidates = collectCandidateGaps(context.store, spaceId, sourceIdFilter, gapIdFilter);
     const requestedLimit = Math.max(1, input.limit ?? DEFAULT_REFINEMENT_LIMIT);
-    const effectiveLimit = Math.min(requestedLimit, MAX_REFINEMENT_LIMIT);
+    const cappedLimit = Math.min(requestedLimit, MAX_REFINEMENT_LIMIT);
     const maxRunMs = Math.min(MAX_REFINEMENT_RUN_MS, Math.max(5_000, input.maxRunMs ?? DEFAULT_REFINEMENT_RUN_MS));
     const startedAt = Date.now();
-    const gaps = candidates.slice(0, effectiveLimit);
-    let truncated = candidates.length > gaps.length || requestedLimit > effectiveLimit;
+    const gaps = candidates.slice(0, cappedLimit);
+    const effectiveLimit = gaps.length;
+    let truncated = candidates.length > gaps.length || requestedLimit > cappedLimit;
     let budgetExhausted = false;
     let processedGaps = 0;
     let repairableGaps = 0;
@@ -385,14 +387,17 @@ function buildGapContext(store, spaceId, gap) {
             .map((edge) => edge.fromId),
     ]);
     const directSources = sourceIds.map((id) => sourcesById.get(id)).filter((source) => Boolean(source));
-    const linkedObjects = uniqueById([
-        ...readStringArray(gap.metadata.linkedObjectIds).map((id) => nodesById.get(id)).filter((node) => Boolean(node)),
-        ...sourceIds.flatMap((sourceId) => linkedObjectsForSource(sourceId, edges, nodesById)),
-        ...edges
-            .filter((edge) => edge.fromKind === 'node' && edge.toKind === 'node' && edge.toId === gap.id)
-            .map((edge) => nodesById.get(edge.fromId))
-            .filter((node) => Boolean(node)),
-    ]);
+    const linkedObjects = canonicalRepairSubjectNodes({
+        text: `${gap.title} ${gap.summary ?? ''}`,
+        nodes: [
+            ...readStringArray(gap.metadata.linkedObjectIds).map((id) => nodesById.get(id)).filter((node) => Boolean(node)),
+            ...sourceIds.flatMap((sourceId) => linkedObjectsForSource(sourceId, edges, nodesById)),
+            ...edges
+                .filter((edge) => edge.fromKind === 'node' && edge.toKind === 'node' && edge.toId === gap.id)
+                .map((edge) => nodesById.get(edge.fromId))
+                .filter((node) => Boolean(node)),
+        ],
+    });
     const sources = uniqueById([
         ...directSources,
         ...linkedObjects.flatMap((object) => sourcesForObject(object.id, edges, sourcesById)),
@@ -502,8 +507,7 @@ async function markGapRepairAttempt(store, gap, spaceId, details) {
 }
 async function linkRepairSources(store, spaceId, gap, sourceIds, query) {
     let linked = 0;
-    const linkedObjectIds = readStringArray(gap.metadata.linkedObjectIds)
-        .filter((nodeId) => Boolean(store.getNode(nodeId)));
+    const linkedObjectIds = repairSubjectIdsForGap(store, spaceId, gap);
     for (const sourceId of sourceIds) {
         if (!store.getSource(sourceId))
             continue;
@@ -538,6 +542,29 @@ async function linkRepairSources(store, spaceId, gap, sourceIds, query) {
     }
     return linked;
 }
+function repairSubjectIdsForGap(store, spaceId, gap) {
+    const edges = store.listEdges();
+    const nodesById = new Map(store.listNodes(10_000)
+        .filter((node) => getKnowledgeSpaceId(node) === spaceId)
+        .map((node) => [node.id, node]));
+    const sourceIds = uniqueStrings([
+        gap.sourceId,
+        ...readStringArray(gap.metadata.sourceIds),
+        ...edges
+            .filter((edge) => edge.toKind === 'node' && edge.toId === gap.id && edge.fromKind === 'source')
+            .map((edge) => edge.fromId),
+    ]);
+    return repairSubjectIds({
+        text: `${gap.title} ${gap.summary ?? ''}`,
+        nodes: [
+            ...readStringArray(gap.metadata.linkedObjectIds).map((nodeId) => nodesById.get(nodeId)),
+            ...edges
+                .filter((edge) => edge.fromKind === 'node' && edge.toKind === 'node' && edge.toId === gap.id)
+                .map((edge) => nodesById.get(edge.fromId)),
+            ...sourceIds.flatMap((sourceId) => linkedObjectsForSource(sourceId, edges, nodesById)),
+        ],
+    });
+}
 function isBudgetError(message) {
     return /\b(timeout|timed out|budget|deadline|exceeded)\b/i.test(message);
 }

package/dist/_internal/platform/knowledge/semantic/service.js

@@ -287,7 +287,7 @@ function activeSelfImproveResult(input) {
         ...emptySelfImproveResult(),
         skippedGaps: 1,
         requestedLimit,
-        effectiveLimit: requestedLimit,
+        effectiveLimit: 0,
         truncated: true,
         budgetExhausted: true,
     };

package/dist/_internal/platform/version.js

@@ -1,6 +1,6 @@
 import { readFileSync } from 'node:fs';
 import { join } from 'node:path';
-let version = '0.28.16';
+let version = '0.28.18';
 try {
     const pkg = JSON.parse(readFileSync(join(import.meta.dir, '..', '..', 'package.json'), 'utf-8'));
     version = pkg.version ?? version;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pellux/goodvibes-sdk",
-  "version": "0.28.16",
+  "version": "0.28.18",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/mgd34msu/goodvibes-sdk.git"
@@ -13,6 +13,7 @@
     "@ast-grep/napi": "^0.42.0",
     "@aws/bedrock-token-generator": "^1.1.0",
     "@mozilla/readability": "^0.6.0",
+    "@smithy/util-retry": "4.3.6",
     "bash-language-server": "file:vendor/bash-language-server",
     "bplist-parser": "^0.3.2",
     "cloudflare": "5.2.0",