@indexnetwork/protocol 1.10.0-rc.155.1 → 1.10.0-rc.158.1

package/dist/opportunity/opportunity.graph.js

@@ -174,9 +174,10 @@ export class OpportunityGraphFactory {
                 };
             }
             const discoveryUserId = state.onBehalfOfUserId ?? state.userId;
-            const [intents, profile] = await Promise.all([
+            const [intents, profile, userPremises] = await Promise.all([
                 this.database.getActiveIntents(discoveryUserId),
                 this.database.getProfile(discoveryUserId),
+                this.database.getPremisesForUser(discoveryUserId, 'ACTIVE'),
             ]);
             const indexedIntents = intents.map((intent) => ({
                 intentId: intent.id,
@@ -192,13 +193,20 @@ export class OpportunityGraphFactory {
                     attributes: profile.attributes ?? undefined,
                 }
                 : null;
+            const sourcePremises = (userPremises ?? [])
+                .filter(p => p.embedding && p.embedding.length > 0)
+                .map(p => ({
+                premiseId: p.id,
+                embedding: p.embedding,
+            }));
             return {
                 userNetworks: userNetworkIds,
                 indexedIntents,
                 sourceProfile,
+                sourcePremises,
                 trace: [{
                         node: "prep",
-                        detail: `${userNetworkIds.length} network(s), ${intents.length} intent(s), ${profile ? 'profile loaded' : 'no profile'}`,
+                        detail: `${userNetworkIds.length} network(s), ${intents.length} intent(s), ${sourcePremises.length} premise(s), ${profile ? 'profile loaded' : 'no profile'}`,
                     }],
             };
         }, { context: { userId: state.userId }, logOutput: true }).catch((error) => {
@@ -696,12 +704,30 @@ export class OpportunityGraphFactory {
                                         merged: merged.length,
                                     },
                                 });
-                                return { candidates: filterByTarget(merged), trace: traceEntries };
+                                const premiseCands = await runPremiseDiscovery();
+                                const withPremises = mergePremiseCandidates(merged, premiseCands);
+                                if (premiseCands.length > 0) {
+                                    traceEntries.push({ node: "discovery", detail: `+ Premise search → ${premiseCands.length} candidate(s), merged to ${withPremises.length}` });
+                                }
+                                return { candidates: filterByTarget(withPremises), trace: traceEntries };
+                            }
+                            const premiseCands = await runPremiseDiscovery();
+                            const withPremises = mergePremiseCandidates(queryCandidates, premiseCands);
+                            if (premiseCands.length > 0) {
+                                traceEntries.push({ node: "discovery", detail: `+ Premise search → ${premiseCands.length} candidate(s), merged to ${withPremises.length}` });
                             }
-                            return { candidates: filterByTarget(queryCandidates), trace: traceEntries };
+                            return { candidates: filterByTarget(withPremises), trace: traceEntries };
                         }
                         // No search query - use profile embedding directly (mirror-only)
                         if (!vector || vector.length === 0) {
+                            // Still attempt premise-based discovery even without a profile vector
+                            const premiseCands = await runPremiseDiscovery();
+                            if (premiseCands.length > 0) {
+                                return {
+                                    candidates: filterByTarget(premiseCands),
+                                    trace: [{ node: "discovery", detail: `No profile vector; premise search → ${premiseCands.length} candidate(s)` }],
+                                };
+                            }
                             return { candidates: [] };
                         }
                         const allCandidates = [];
@@ -799,8 +825,13 @@ export class OpportunityGraphFactory {
                                 },
                             });
                         }
+                        const premiseCands = await runPremiseDiscovery();
+                        const withPremises = mergePremiseCandidates(candidates, premiseCands);
+                        if (premiseCands.length > 0) {
+                            traceEntries.push({ node: "discovery", detail: `+ Premise search → ${premiseCands.length} candidate(s), merged to ${withPremises.length}` });
+                        }
                         return {
-                            candidates: filterByTarget(candidates),
+                            candidates: filterByTarget(withPremises),
                             trace: traceEntries,
                         };
                     }
@@ -892,12 +923,85 @@ export class OpportunityGraphFactory {
                         }
                         return Array.from(byKey.values());
                     }
+                    /**
+                     * Premise-to-premise discovery (path D).
+                     * Searches for other users' premises similar to the discoverer's premises,
+                     * scoped to target networks. Additive — merges into existing candidates.
+                     */
+                    async function runPremiseDiscovery() {
+                        if (!state.sourcePremises?.length)
+                            return [];
+                        const targetNetworkIds = state.targetNetworks.map(t => t.networkId);
+                        if (targetNetworkIds.length === 0)
+                            return [];
+                        logger.verbose('[Graph:Discovery] runPremiseDiscovery start', {
+                            premiseCount: state.sourcePremises.length,
+                            targetNetworks: targetNetworkIds.length,
+                        });
+                        const searchResults = await Promise.all(state.sourcePremises.map(sp => self.database.searchPremisesBySimilarity({
+                            embedding: sp.embedding,
+                            networkIds: targetNetworkIds,
+                            excludeUserId: discoveryUserId,
+                            limit: 20,
+                        })));
+                        const premiseCandidates = [];
+                        for (const results of searchResults) {
+                            for (const r of results) {
+                                premiseCandidates.push({
+                                    candidateUserId: r.userId,
+                                    candidatePremiseId: r.premiseId,
+                                    networkId: r.networkId,
+                                    similarity: typeof r.similarity === 'number' ? r.similarity : parseFloat(String(r.similarity)),
+                                    lens: 'premise_match',
+                                    candidatePayload: r.assertionText ?? '',
+                                    discoverySource: 'premise-similarity',
+                                });
+                            }
+                        }
+                        // Dedup by userId + premiseId + networkId (a premise can appear in multiple networks)
+                        const byKey = new Map();
+                        for (const c of premiseCandidates) {
+                            const key = `${c.candidateUserId}:${c.candidatePremiseId ?? 'none'}:${c.networkId}`;
+                            if (!byKey.has(key) || c.similarity > (byKey.get(key)?.similarity ?? 0)) {
+                                byKey.set(key, c);
+                            }
+                        }
+                        const deduped = Array.from(byKey.values());
+                        logger.verbose('[Graph:Discovery] runPremiseDiscovery complete', {
+                            rawCount: premiseCandidates.length,
+                            dedupedCount: deduped.length,
+                        });
+                        return deduped;
+                    }
+                    /**
+                     * Merge premise candidates into an existing candidate list.
+                     * Deduplicates by userId + networkId + discoverySource + entityId.
+                     */
+                    function mergePremiseCandidates(existing, premise) {
+                        if (premise.length === 0)
+                            return existing;
+                        const merged = new Map();
+                        for (const c of [...existing, ...premise]) {
+                            const key = `${c.candidateUserId}:${c.networkId}:${c.discoverySource}:${c.candidateIntentId ?? c.candidatePremiseId ?? 'none'}`;
+                            if (!merged.has(key) || c.similarity > (merged.get(key)?.similarity ?? 0)) {
+                                merged.set(key, c);
+                            }
+                        }
+                        return Array.from(merged.values());
+                    }
                     const resolvedIntent = state.resolvedTriggerIntentId
                         ? state.indexedIntents.find((i) => i.intentId === state.resolvedTriggerIntentId)
                         : state.indexedIntents[0];
                     const searchText = state.searchQuery ?? resolvedIntent?.payload ?? '';
                     if (!searchText) {
                         logger.warn('[Graph:Discovery] No search text available for intent path');
+                        const premiseCands = await runPremiseDiscovery();
+                        if (premiseCands.length > 0) {
+                            return {
+                                candidates: filterByTarget(premiseCands),
+                                trace: [{ node: "discovery", detail: `No search text; premise search → ${premiseCands.length} candidate(s)` }],
+                            };
+                        }
                         return { candidates: [] };
                     }
                     const discovererContext = buildDiscovererContext(state.sourceProfile, state.indexedIntents);
@@ -914,6 +1018,14 @@ export class OpportunityGraphFactory {
                     const hydeEmbeddings = hydeResult.hydeEmbeddings;
                     const lenses = hydeResult.lenses ?? [];
                     if (!hydeEmbeddings || Object.keys(hydeEmbeddings).length === 0) {
+                        const premiseCands = await runPremiseDiscovery();
+                        if (premiseCands.length > 0) {
+                            return {
+                                hydeEmbeddings: {},
+                                candidates: filterByTarget(premiseCands),
+                                trace: [{ node: "discovery", detail: `No HyDE embeddings; premise search → ${premiseCands.length} candidate(s)` }],
+                            };
+                        }
                         return { hydeEmbeddings: {}, candidates: [] };
                     }
                     const lensMap = new Map(lenses.map(l => [l.label, l]));
@@ -1039,9 +1151,14 @@ export class OpportunityGraphFactory {
                             },
                         });
                     }
+                    const premiseCands = await runPremiseDiscovery();
+                    const withPremises = mergePremiseCandidates(candidates, premiseCands);
+                    if (premiseCands.length > 0) {
+                        traceEntries.push({ node: "discovery", detail: `+ Premise search → ${premiseCands.length} candidate(s), merged to ${withPremises.length}` });
+                    }
                     return {
                         hydeEmbeddings: hydeEmbeddings,
-                        candidates: filterByTarget(candidates),
+                        candidates: filterByTarget(withPremises),
                         trace: traceEntries,
                     };
                 }
@@ -2326,11 +2443,23 @@ export class OpportunityGraphFactory {
                         }
                         else {
                             // Discovery path: opportunity_graph source, no introducer, lifecycle guard for agent/patient.
+                            // Build premise lookup from discovery candidates for premise tracking.
+                            // When multiple premise candidates exist for the same user, keep the highest-similarity one.
+                            const premiseLookup = new Map();
+                            for (const c of state.candidates ?? []) {
+                                if (c.discoverySource === 'premise-similarity' && c.candidatePremiseId) {
+                                    const existing = premiseLookup.get(c.candidateUserId);
+                                    if (!existing || c.similarity > existing.similarity) {
+                                        premiseLookup.set(c.candidateUserId, { premiseId: c.candidatePremiseId, similarity: c.similarity });
+                                    }
+                                }
+                            }
                             const evaluatorActors = evaluated.actors.map((a) => ({
                                 networkId: a.networkId ?? indexIdForActors,
                                 userId: a.userId,
                                 role: a.role,
                                 ...(a.intentId ? { intent: a.intentId } : {}),
+                                ...(premiseLookup.has(a.userId) ? { premise: premiseLookup.get(a.userId).premiseId } : {}),
                             }));
                             actors = evaluatorActors;
                             const hasIntroducerActor = actors.some(a => a.role === 'introducer');