@indexnetwork/protocol 8.1.1-rc.422.1 → 8.2.0-rc.423.1

package/dist/capabilities/opportunities.facade.d.ts

@@ -18,6 +18,8 @@ export { OpportunityPresenter, gatherPresenterContext } from "../opportunity/app
 export type { PresenterDatabase } from "../opportunity/application/opportunity.presenter.js";
 export { createOpportunityTools } from "../opportunity/application/opportunity.tools.js";
 export type { OpportunityToolDeps } from "./opportunities.tools.port.js";
+export { discoveryAllowedTypes, discoveryIntentMatchingEnabled, discoveryProfileMatchingEnabled, discoveryProfileSource, resetDiscoveryEnvWarningsForTests, } from "../opportunity/discovery.env.js";
+export type { DiscoveryMatchType, DiscoveryProfileSource } from "../opportunity/discovery.env.js";
 export { PoolDiscriminatorMiner } from "../opportunity/discriminator/discriminator.miner.js";
 export { PoolDiscriminatorAssigner } from "../opportunity/discriminator/discriminator.assigner.js";
 export type { PoolDiscriminatorAssignmentInput, PoolDiscriminatorAssignedAxis } from "../opportunity/discriminator/discriminator.assigner.js";

package/dist/capabilities/opportunities.facade.js

@@ -19,6 +19,8 @@ export { OpportunityEvaluator } from "../opportunity/application/opportunity.eva
 export { OpportunityPresenter, gatherPresenterContext } from "../opportunity/application/opportunity.presenter.js";
 // ── MCP tool factory ──────────────────────────────────────────────────────────
 export { createOpportunityTools } from "../opportunity/application/opportunity.tools.js";
+// ── Discovery env accessors ───────────────────────────────────────────────────
+export { discoveryAllowedTypes, discoveryIntentMatchingEnabled, discoveryProfileMatchingEnabled, discoveryProfileSource, resetDiscoveryEnvWarningsForTests, } from "../opportunity/discovery.env.js";
 // ── Pool discriminator (Lens A) ───────────────────────────────────────────────
 export { PoolDiscriminatorMiner } from "../opportunity/discriminator/discriminator.miner.js";
 export { PoolDiscriminatorAssigner } from "../opportunity/discriminator/discriminator.assigner.js";

package/dist/index.d.ts

@@ -89,6 +89,8 @@ export type { PoolDiscriminatorAssignmentInput, PoolDiscriminatorAssignedAxis }
 export { runPoolDiscriminatorShadow } from "./capabilities/opportunities.facade.js";
 export { poolQuestionsMiningMode, poolQuestionsMode, poolQuestionsPushMode, poolQuestionsStampNewborn, POOL_DISCRIMINATOR_MIN_POOL_SIZE, POOL_DISCRIMINATOR_MAX_CANDIDATES, POOL_DISCRIMINATOR_MAX_PUBLIC_CONTEXT_CHARS, POOL_QUESTION_MIN_VOI, POOL_QUESTION_MAX_PENDING_PER_INTENT, } from "./capabilities/opportunities.facade.js";
 export { poolQuestionsRanking, POOL_RERUN_DEBOUNCE_MS } from "./capabilities/opportunities.facade.js";
+export { discoveryAllowedTypes, discoveryIntentMatchingEnabled, discoveryProfileMatchingEnabled, discoveryProfileSource, resetDiscoveryEnvWarningsForTests, } from "./capabilities/opportunities.facade.js";
+export type { DiscoveryMatchType, DiscoveryProfileSource } from "./capabilities/opportunities.facade.js";
 export { poolQuestionsVisitTrigger, POOL_VISIT_MINING_DEBOUNCE_MS } from "./capabilities/opportunities.facade.js";
 export { buildPoolAdjustment, planPoolAdjustments, mergePoolAdjustment } from "./capabilities/opportunities.facade.js";
 export type { PoolAdjustment, PoolAdjustmentSignal } from "./capabilities/opportunities.facade.js";

package/dist/index.js

@@ -74,6 +74,8 @@ export { PoolDiscriminatorAssigner } from "./capabilities/opportunities.facade.j
 export { runPoolDiscriminatorShadow } from "./capabilities/opportunities.facade.js";
 export { poolQuestionsMiningMode, poolQuestionsMode, poolQuestionsPushMode, poolQuestionsStampNewborn, POOL_DISCRIMINATOR_MIN_POOL_SIZE, POOL_DISCRIMINATOR_MAX_CANDIDATES, POOL_DISCRIMINATOR_MAX_PUBLIC_CONTEXT_CHARS, POOL_QUESTION_MIN_VOI, POOL_QUESTION_MAX_PENDING_PER_INTENT, } from "./capabilities/opportunities.facade.js";
 export { poolQuestionsRanking, POOL_RERUN_DEBOUNCE_MS } from "./capabilities/opportunities.facade.js";
+// Discovery env accessors (IND-XXX)
+export { discoveryAllowedTypes, discoveryIntentMatchingEnabled, discoveryProfileMatchingEnabled, discoveryProfileSource, resetDiscoveryEnvWarningsForTests, } from "./capabilities/opportunities.facade.js";
 export { poolQuestionsVisitTrigger, POOL_VISIT_MINING_DEBOUNCE_MS } from "./capabilities/opportunities.facade.js";
 export { buildPoolAdjustment, planPoolAdjustments, mergePoolAdjustment } from "./capabilities/opportunities.facade.js";
 export { synthesizePoolQuestion, selectQuestionDiscriminators, toQuestionDiscriminator, BOTH_MATTER_LABEL } from "./capabilities/opportunities.facade.js";

package/dist/opportunity/application/opportunity.evaluator.d.ts

@@ -77,7 +77,7 @@ declare const ActorSchema: z.ZodObject<{
     intentId: string | null;
     evidenceKey?: string | null | undefined;
 }>;
-declare const OpportunityWithActorsSchema: z.ZodObject<{
+declare const _OpportunityWithActorsSchema: z.ZodObject<{
     reasoning: z.ZodString;
     score: z.ZodNumber;
     actors: z.ZodArray<z.ZodObject<{
@@ -116,9 +116,11 @@ declare const OpportunityWithActorsSchema: z.ZodObject<{
     }[];
 }>;
 declare const entityBundleResponseFormat: z.ZodObject<{
-    opportunities: z.ZodArray<z.ZodObject<{
-        reasoning: z.ZodString;
+    verdicts: z.ZodArray<z.ZodObject<{
+        candidateId: z.ZodString;
+        accepted: z.ZodBoolean;
         score: z.ZodNumber;
+        reasoning: z.ZodString;
         actors: z.ZodArray<z.ZodObject<{
             userId: z.ZodString;
             role: z.ZodEnum<["agent", "patient", "peer"]>;
@@ -138,48 +140,60 @@ declare const entityBundleResponseFormat: z.ZodObject<{
     }, "strip", z.ZodTypeAny, {
         reasoning: string;
         score: number;
+        accepted: boolean;
         actors: {
             userId: string;
             role: "agent" | "patient" | "peer";
             intentId: string | null;
             evidenceKey?: string | null | undefined;
         }[];
+        candidateId: string;
     }, {
         reasoning: string;
         score: number;
+        accepted: boolean;
         actors: {
             userId: string;
             role: "agent" | "patient" | "peer";
             intentId: string | null;
             evidenceKey?: string | null | undefined;
         }[];
+        candidateId: string;
     }>, "many">;
 }, "strip", z.ZodTypeAny, {
-    opportunities: {
+    verdicts: {
         reasoning: string;
         score: number;
+        accepted: boolean;
         actors: {
             userId: string;
             role: "agent" | "patient" | "peer";
             intentId: string | null;
             evidenceKey?: string | null | undefined;
         }[];
+        candidateId: string;
     }[];
 }, {
-    opportunities: {
+    verdicts: {
         reasoning: string;
         score: number;
+        accepted: boolean;
         actors: {
             userId: string;
             role: "agent" | "patient" | "peer";
             intentId: string | null;
             evidenceKey?: string | null | undefined;
         }[];
+        candidateId: string;
     }[];
 }>;
 export type EvaluatorActor = z.infer<typeof ActorSchema>;
-export type EvaluatedOpportunityWithActors = z.infer<typeof OpportunityWithActorsSchema>;
+export type EvaluatedOpportunityWithActors = z.infer<typeof _OpportunityWithActorsSchema>;
 export type EvaluatorOutputBundle = z.infer<typeof entityBundleResponseFormat>;
+/** Raised only after both bounded attempts return an incomplete evaluator batch. */
+export declare class EvaluatorIncompleteError extends Error {
+    constructor();
+}
 type Opportunity = z.infer<typeof OpportunitySchema>;
 export interface CandidateProfile {
     userId: string;

package/dist/opportunity/application/opportunity.evaluator.js

@@ -114,17 +114,17 @@ Match patterns to consider:
 4. Intents+profile-to-intents+profile: Complementary or reciprocal goals between two or more people.
 
 Output:
-- A list of 0..N opportunities. Each opportunity has:
-  - reasoning: Third-party analytical explanation (for other LLM agents). Mention entities by role. Do NOT use "you". Never leak private intents.
-  - score: 0-100.
-    - 90-100: Must Meet — candidate's PRIMARY role directly matches what the discoverer seeks.
-      Example: discoverer seeks "AI/ML co-founder" → candidate IS an AI/ML engineer who wants to co-found.
-    - 70-89: Should Meet — meaningful overlap on role type AND complementary intent.
-    - 50-69: Worth Considering — tangential overlap only.
-    - <30 (return empty): Complementary-role mismatch (candidate cannot fill the discoverer's open argument position), same-side match, or already acquainted.
-      Example: discoverer seeks "co-founder" → candidate is a VC investor. The investor's contribution is external to the co-founding relation; they cannot substitute into it. Score 0.
-  - IMPORTANT: Include ALL reasonable matches with scores >= 30, and ONLY those. Any candidate you would reject (complementary-role mismatch, same-side, already-acquainted, or a hard location mismatch) must score strictly below 30 and be omitted entirely — the surfacing threshold is 30, so a rejected candidate parked at exactly 30 would be wrongly surfaced.
-  - actors: At least 2 actors per opportunity. Each actor has:
+- A list of verdicts with EXACTLY ONE verdict for EVERY candidate entity (never omit a candidate).
+- Each verdict has candidateId (the candidate USER ID), accepted, reasoning, score, and actors.
+- accepted=true verdicts must include exactly the source and that candidate as actors. accepted=false verdicts may use an empty actor list.
+- Rejected candidates still require a verdict: set accepted=false and score below the appropriate threshold.
+- A verdict score is 0-100:
+  - 90-100: Must Meet — candidate's PRIMARY role directly matches what the discoverer seeks.
+  - 70-89: Should Meet — meaningful overlap on role type AND complementary intent.
+  - 50-69: Worth Considering — tangential overlap only.
+  - <30: Complementary-role mismatch (candidate cannot fill the discoverer's open argument position), same-side match, or already acquainted.
+- IMPORTANT: Every candidate must be represented once and only once. Do not return an opportunity list and do not omit rejected candidates.
+- Actors in accepted verdicts:
     - userId
     - role: "agent" (can do something for others), "patient" (needs something from others), "peer" (symmetric collaboration)
     - intentId (optional): if the match is intent-driven, the specific intent ID for that user
@@ -180,14 +180,55 @@ const ActorSchema = z.object({
         .describe('If the match is intent-driven, the specific intent ID; null otherwise'),
     evidenceKey: z.string().nullable().optional().describe('Stable evidence key for the matched entity; null if unknown'),
 });
-const OpportunityWithActorsSchema = z.object({
+const _OpportunityWithActorsSchema = z.object({
     reasoning: z.string(),
     score: z.number().min(0).max(100),
     actors: z.array(ActorSchema).min(2).describe('All actors in this opportunity with their roles'),
 });
+const EvaluatorVerdictSchema = z.object({
+    candidateId: z.string().describe('The candidate USER ID being evaluated'),
+    accepted: z.boolean().describe('Whether this candidate is a qualifying opportunity'),
+    score: z.number().min(0).max(100),
+    reasoning: z.string(),
+    actors: z.array(ActorSchema).describe('Accepted verdicts include source and candidate actors; rejected verdicts may use an empty list'),
+});
 const entityBundleResponseFormat = z.object({
-    opportunities: z.array(OpportunityWithActorsSchema).describe('List of opportunities (0..N)'),
+    verdicts: z.array(EvaluatorVerdictSchema).describe('Exactly one verdict for every candidate entity; include rejected candidates'),
 });
+/** Raised only after both bounded attempts return an incomplete evaluator batch. */
+export class EvaluatorIncompleteError extends Error {
+    constructor() {
+        super('evaluator-incomplete');
+        this.name = 'EvaluatorIncompleteError';
+    }
+}
+function reconcileEvaluatorVerdicts(verdicts, candidateIds, discovererId, introductionMode) {
+    const expected = new Set(candidateIds);
+    const seen = new Set();
+    for (const verdict of verdicts) {
+        if (!expected.has(verdict.candidateId) || seen.has(verdict.candidateId)) {
+            throw new EvaluatorIncompleteError();
+        }
+        if (verdict.accepted) {
+            const expectedActorIds = introductionMode
+                ? expected
+                : new Set([discovererId, verdict.candidateId]);
+            const actorIds = verdict.actors.map((actor) => actor.userId);
+            if (actorIds.length !== expectedActorIds.size ||
+                new Set(actorIds).size !== expectedActorIds.size ||
+                actorIds.some((actorId) => !expectedActorIds.has(actorId))) {
+                throw new EvaluatorIncompleteError();
+            }
+        }
+        seen.add(verdict.candidateId);
+    }
+    if (seen.size !== expected.size)
+        throw new EvaluatorIncompleteError();
+    return verdicts;
+}
+function isEvaluatorOutputError(error) {
+    return error instanceof z.ZodError || error instanceof EvaluatorIncompleteError;
+}
 export class OpportunityEvaluator {
     constructor(options) {
         this.model = createStructuredModel("opportunityEvaluator", responseFormat, {
@@ -376,41 +417,57 @@ ${renderOpportunityEvidenceForPrompt(e.evidence ?? [])}`;
             new SystemMessage(entityBundleSystemPrompt),
             new HumanMessage(humanContent),
         ];
+        const candidateIds = input.entities
+            .filter((entity) => entity.userId !== input.discovererId)
+            .map((entity) => entity.userId);
+        if (new Set(candidateIds).size !== candidateIds.length) {
+            throw new EvaluatorIncompleteError();
+        }
         let parsedTotal = 0;
-        try {
-            const result = await invokeWithAbortSignal(this.entityBundleModel, messages, options.signal);
-            const parsed = entityBundleResponseFormat.parse(result);
-            for (const op of parsed.opportunities) {
-                op.reasoning = stripUuids(op.reasoning);
+        let incompleteReason;
+        for (let attempt = 0; attempt < 2; attempt++) {
+            try {
+                const result = await invokeWithAbortSignal(this.entityBundleModel, messages, options.signal);
+                const parsed = entityBundleResponseFormat.parse(result);
+                parsedTotal = parsed.verdicts.length;
+                const verdicts = reconcileEvaluatorVerdicts(parsed.verdicts, candidateIds, input.discovererId, input.introductionMode ?? false);
+                const accepted = verdicts
+                    .filter((verdict) => verdict.accepted)
+                    .map((verdict) => ({
+                    reasoning: stripUuids(verdict.reasoning),
+                    score: verdict.score,
+                    actors: verdict.actors,
+                }))
+                    .filter((op) => op.actors.length >= 2);
+                // Persistence safety is deterministic and precedes every score/returnAll
+                // path. Network/context placement is not typed support provenance, so an
+                // unsupported affiliation or presence claim rejects the whole result.
+                const claimSafe = accepted.filter((op) => !hasUnsupportedOpportunityClaim(op.reasoning));
+                const introGuard = input.introductionMode ? claimSafe.filter((op) => op.actors.length === 2) : claimSafe;
+                const filtered = introGuard.filter((op) => op.score >= minScore);
+                invokeEntityBundleLog.verbose('Done', {
+                    total: verdicts.length,
+                    afterClaimGuard: claimSafe.length,
+                    afterIntroGuard: introGuard.length,
+                    accepted: filtered.length,
+                    returnAll,
+                });
+                return returnAll ? introGuard : filtered;
+            }
+            catch (error) {
+                if (!isEvaluatorOutputError(error))
+                    throw error;
+                incompleteReason = error instanceof Error ? error.message : 'invalid output';
             }
-            parsedTotal = parsed.opportunities.length;
-            // Persistence safety is deterministic and precedes every score/returnAll
-            // path. Network/context placement is not typed support provenance, so an
-            // unsupported affiliation or presence claim rejects the whole result.
-            const claimSafe = parsed.opportunities.filter((op) => !hasUnsupportedOpportunityClaim(op.reasoning));
-            const introGuard = input.introductionMode
-                ? claimSafe.filter((op) => op.actors.length === 2)
-                : claimSafe;
-            const filtered = introGuard.filter((op) => op.score >= minScore);
-            invokeEntityBundleLog.verbose('Done', {
-                total: parsed.opportunities.length,
-                afterClaimGuard: claimSafe.length,
-                afterIntroGuard: introGuard.length,
-                accepted: filtered.length,
-                returnAll,
-            });
-            return returnAll ? introGuard : filtered;
-        }
-        catch (llmError) {
-            invokeEntityBundleLog.error('Failed', {
-                discovererId: input.discovererId,
-                totalEntities,
-                parsedTotal,
-                minScore,
-                llmError,
-            });
-            throw llmError;
         }
+        invokeEntityBundleLog.error('Evaluator batch incomplete', {
+            discovererId: input.discovererId,
+            totalEntities,
+            parsedTotal,
+            minScore,
+            reason: incompleteReason,
+        });
+        throw new EvaluatorIncompleteError();
     }
     /**
      * Factory method to expose the agent as a LangChain tool.

package/dist/opportunity/application/opportunity.graph.d.ts

@@ -29,6 +29,8 @@ export type OpportunityEvaluatorLike = {
     }>>;
     invokeEntityBundle?: (input: EvaluatorInput, options: {
         minScore?: number;
+        returnAll?: boolean;
+        signal?: AbortSignal;
     }) => Promise<Array<{
         reasoning: string;
         score: number;
@@ -49,6 +51,12 @@ import { type StampNewbornOpportunitiesFn } from './opportunity.newborn-stamping
 export type { QueueOpportunityNotificationFn } from './opportunity.lifecycle.js';
 export type { StampNewbornOpportunitiesFn, StampNewbornOpportunitiesInput } from './opportunity.newborn-stamping.js';
 export { buildPrioritizedNegotiationIntents } from './opportunity.existing-negotiation.js';
+/**
+ * Error text can include provider response bodies, URLs, and credentials. Keep
+ * observability useful by retaining only a conservative error class at this
+ * boundary; detailed errors are intentionally not emitted from graph traces.
+ */
+export declare function safeOpportunityGraphError(_error: unknown): string;
 /** Input shape for the HyDE graph invoke call (query-based embedding). */
 export interface HydeGeneratorInvokeInput {
     sourceType: 'query';