@indexnetwork/protocol 22.0.0-rc.498.1 → 64.0.0-rc.604.2

package/dist/opportunities/negotiation-evidence/negotiation-evidence.types.d.ts

@@ -1,191 +0,0 @@
-/**
- * Lens C negotiation-evidence — shared types (IND-433).
- *
- * Lens C mines neutral clarification hypotheses from RECURRING negotiation
- * evidence, read in place at mining time. It never builds a durable transcript
- * projection and never summarizes an entire pair DM; the only content it will
- * ever touch is a narrow, positively-constructed allowlist:
- *
- *   - authoritative owner answers (the recipient's own answers),
- *   - structured bilateral actions / coarse outcomes, and
- *   - explicitly shared message content.
- *
- * Everything else — screen/evaluator reasoning, agent chain-of-thought,
- * `memoryHints`, private negotiator memories/reflections, disclosure subjects,
- * untagged shared answers, and old synthesized digests — is excluded by
- * construction (never mapped into an {@link AllowlistedEvidence}).
- */
-/** The four allowlisted evidence families. Nothing else may be surfaced. */
-export type EvidenceKind = "owner_answer" | "bilateral_action" | "coarse_outcome" | "shared_message";
-/**
- * Who authored an evidence unit. `system` covers structured bilateral facts
- * (actions/outcomes) that belong to neither party's voice. The distinction is
- * load-bearing: a counterparty statement may support an OBSERVATION but never
- * a fact or preference ABOUT the recipient (IND-433).
- */
-export type EvidenceSpeaker = "owner" | "counterparty" | "system";
-/**
- * One unit of allowlisted evidence, extracted in place for exactly one
- * (recipient, intent, opportunity, task) tuple. Provenance travels with the
- * unit so cross-recipient / cross-intent / cross-opportunity / cross-network /
- * cross-task / cross-speaker contamination is a pure-function rejection rather
- * than a downstream concern.
- */
-export interface AllowlistedEvidence {
-    /** Deterministic id, unique within one mining pass: `${kind}:${opportunityId}:${ordinal}`. */
-    evidenceId: string;
-    kind: EvidenceKind;
-    speaker: EvidenceSpeaker;
-    /** The only text a support reference may quote — bounded, exclusion-scrubbed. */
-    content: string;
-    recipientUserId: string;
-    intentId: string;
-    intentFingerprint: string;
-    opportunityId: string;
-    taskId: string;
-    conversationId: string;
-    networkId: string;
-}
-/**
- * One raw negotiation turn as read in place. Untrusted: it still carries the
- * fields Lens C must EXCLUDE (`reasoning`, `askUser`/disclosure). The extractor
- * maps only the allowlisted projection of this record.
- */
-export interface RawEvidenceTurn {
-    /** Turn author user id — mapped to owner/counterparty against the segment. */
-    senderUserId: string;
-    /** Structured bilateral action (propose/accept/counter/decline/...). */
-    action: string;
-    /** Free-text message body, if any. */
-    message?: string | null;
-    /**
-     * True only when this message was EXPLICITLY shared/consented for reuse.
-     * Untagged messages are excluded — Lens C never mines an untagged answer.
-     */
-    sharedTagged?: boolean;
-    /** Chain-of-thought — EXCLUDED. Present here only to prove it is dropped. */
-    reasoning?: string | null;
-    /** Disclosure subject — EXCLUDED. Present here only to prove it is dropped. */
-    disclosureSubject?: string | null;
-}
-/** Coarse, structured outcome facts (no evaluator reasoning). */
-export interface RawEvidenceOutcome {
-    hasOpportunity: boolean;
-    /** `turn_cap | timeout` are coarse; `screened_out` is a private gate → dropped. */
-    reason?: "turn_cap" | "timeout" | "screened_out";
-    /** Agreed collaboration roles, if any. */
-    agreedRoles?: Array<{
-        userId: string;
-        role: string;
-    }>;
-    /** Evaluator reasoning — EXCLUDED. Present here only to prove it is dropped. */
-    reasoning?: string | null;
-}
-/** Authoritative owner answer (the recipient's own answer to a question). */
-export interface RawEvidenceOwnerAnswer {
-    /** Answerer user id — must equal the segment recipient to be authoritative. */
-    answererUserId: string;
-    selectedOptions: string[];
-    freeText?: string;
-}
-/**
- * All in-place negotiation data for ONE opportunity segment, scoped to an
- * exact recipient + intent/fingerprint + opportunity + task. Continuations of
- * the same opportunity arrive as separate segments sharing `opportunityId`;
- * the extractor groups them and counts the opportunity once.
- */
-export interface RawEvidenceSegment {
-    recipientUserId: string;
-    intentId: string;
-    intentFingerprint: string;
-    opportunityId: string;
-    taskId: string;
-    conversationId: string;
-    networkId: string;
-    /** The counterparty in this bilateral negotiation. */
-    counterpartyUserId: string;
-    turns: RawEvidenceTurn[];
-    outcome?: RawEvidenceOutcome | null;
-    ownerAnswers?: RawEvidenceOwnerAnswer[];
-}
-/** The scope a mining pass is bound to — every segment must match it exactly. */
-export interface EvidenceMiningScope {
-    recipientUserId: string;
-    intentId: string;
-    intentFingerprint: string;
-    networkId: string;
-}
-/**
- * The three claim shapes a hypothesis may take. The speaker constraint is
- * enforced against these: `recipient_fact` / `recipient_preference` require
- * owner-authored (or structured bilateral) support; `observation` may also be
- * supported by counterparty statements.
- */
-export type HypothesisClaimType = "observation" | "recipient_fact" | "recipient_preference";
-/** A support reference proposed by the miner (before code-side verification). */
-export interface ProposedSupportRef {
-    /** Must resolve to an {@link AllowlistedEvidence} in the pass. */
-    evidenceId: string;
-    /** Verbatim span the miner copied from that evidence's content. */
-    span: string;
-}
-/** One hypothesis proposed by the miner. */
-export interface MinedEvidenceHypothesis {
-    /** Neutral, non-identifying clarification hypothesis. */
-    statement: string;
-    claimType: HypothesisClaimType;
-    supportRefs: ProposedSupportRef[];
-}
-/** A support reference that resolved against the allowlist. */
-export interface VerifiedSupportRef {
-    evidenceId: string;
-    kind: EvidenceKind;
-    speaker: EvidenceSpeaker;
-    opportunityId: string;
-}
-/**
- * A hypothesis after verification + the recurrence gate. Retained hypotheses
- * are returned for OFFLINE review only — shadow mode never persists or logs
- * their text (see {@link NegotiationEvidenceTelemetry}).
- */
-export interface RetainedEvidenceHypothesis {
-    statement: string;
-    claimType: HypothesisClaimType;
-    support: VerifiedSupportRef[];
-    /** Count of DISTINCT opportunities in `support` — the recurrence measure. */
-    distinctOpportunities: number;
-}
-/**
- * Aggregate-only telemetry. Deliberately carries NO evidence content, NO
- * hypothesis text, and NO spans — only counts — so it is safe to emit to
- * routine logs without leaking internal negotiation content.
- */
-export interface NegotiationEvidenceTelemetry {
-    recipientUserId: string;
-    intentId: string;
-    /** Raw segments supplied to the pass (pre-grouping). */
-    segments: number;
-    /** Distinct opportunities after continuation grouping. */
-    distinctOpportunities: number;
-    /** Allowlisted evidence unit counts, by kind. */
-    evidenceCounts: Record<EvidenceKind, number>;
-    /** Records dropped by allowlist / exclusion / provenance mismatch. */
-    excludedRecords: number;
-    hypothesesMined: number;
-    /** Hypotheses whose every support ref verified against the allowlist. */
-    hypothesesSupported: number;
-    /** Supported hypotheses that also met the distinct-opportunity floor. */
-    hypothesesRecurrent: number;
-    /** Hypotheses discarded (unsupported ref, speaker violation, or too rare). */
-    hypothesesDiscarded: number;
-}
-/** Result of one shadow mining pass. */
-export interface NegotiationEvidenceShadowResult {
-    /** Safe-to-log aggregate counts. */
-    telemetry: NegotiationEvidenceTelemetry;
-    /**
-     * Retained recurrent hypotheses for offline eval. In shadow mode the caller
-     * MUST NOT persist these or write them to routine logs.
-     */
-    hypotheses: RetainedEvidenceHypothesis[];
-}

package/dist/opportunities/negotiation-evidence/negotiation-evidence.types.js

@@ -1,18 +0,0 @@
-/**
- * Lens C negotiation-evidence — shared types (IND-433).
- *
- * Lens C mines neutral clarification hypotheses from RECURRING negotiation
- * evidence, read in place at mining time. It never builds a durable transcript
- * projection and never summarizes an entire pair DM; the only content it will
- * ever touch is a narrow, positively-constructed allowlist:
- *
- *   - authoritative owner answers (the recipient's own answers),
- *   - structured bilateral actions / coarse outcomes, and
- *   - explicitly shared message content.
- *
- * Everything else — screen/evaluator reasoning, agent chain-of-thought,
- * `memoryHints`, private negotiator memories/reflections, disclosure subjects,
- * untagged shared answers, and old synthesized digests — is excluded by
- * construction (never mapped into an {@link AllowlistedEvidence}).
- */
-export {};

package/dist/opportunities/negotiation-evidence/negotiation-evidence.verifier.d.ts

@@ -1,34 +0,0 @@
-/**
- * Lens C support-reference verification + recurrence gate (IND-433).
- *
- * A mined hypothesis is retained ONLY when:
- *   1. it carries at least one support reference,
- *   2. EVERY support reference resolves to an allowlisted evidence unit in
- *      this pass AND quotes a verbatim span of that unit's content,
- *   3. the speaker constraint holds — a claim that is a fact or preference
- *      ABOUT the recipient may never rest on a counterparty statement, and
- *   4. its verified support spans at least `minDistinctOpportunities` DISTINCT
- *      opportunities (recurrence). Continuations were already grouped upstream,
- *      so same-pair repetition cannot inflate this.
- *
- * Any failure discards the whole hypothesis — there is no partial retention.
- */
-import type { AllowlistedEvidence, MinedEvidenceHypothesis, RetainedEvidenceHypothesis } from "./negotiation-evidence.types.js";
-/** Result of verifying a batch of mined hypotheses. */
-export interface VerificationResult {
-    /** Hypotheses that passed verification AND the recurrence gate. */
-    retained: RetainedEvidenceHypothesis[];
-    /** Hypotheses whose every support ref verified (pre-recurrence). */
-    supported: number;
-    /** Supported hypotheses that also met the distinct-opportunity floor. */
-    recurrent: number;
-    /** Hypotheses discarded for any reason (mined − recurrent). */
-    discarded: number;
-}
-/** True when `span` is a meaningful verbatim substring of `content`. */
-export declare function evidenceSpanMatches(content: string, span: string): boolean;
-/**
- * Verify + recurrence-gate a batch of mined hypotheses against the allowlisted
- * evidence produced for the same pass.
- */
-export declare function verifyHypotheses(hypotheses: MinedEvidenceHypothesis[], evidence: AllowlistedEvidence[], minDistinctOpportunities: number): VerificationResult;

package/dist/opportunities/negotiation-evidence/negotiation-evidence.verifier.js

@@ -1,91 +0,0 @@
-/** Minimum normalized span length that counts as meaningful verbatim evidence. */
-const MIN_SPAN_CHARS = 8;
-/** Lowercase, fold typographic punctuation, collapse whitespace. */
-function normalizeForMatch(s) {
-    return s
-        .toLowerCase()
-        .replace(/[\u2018\u2019\u02bc]/g, "'")
-        .replace(/[\u201c\u201d]/g, '"')
-        .replace(/[\u2013\u2014]/g, "-")
-        .replace(/\u2026/g, "...")
-        .replace(/\s+/g, " ")
-        .trim();
-}
-/** Strip wrapping quotes / edge punctuation the LLM habitually adds. */
-function stripEdgePunctuation(s) {
-    return s
-        .replace(/^[\s"'.,;:!?()\u2018\u2019\u201c\u201d]+/, "")
-        .replace(/[\s"'.,;:!?()\u2018\u2019\u201c\u201d]+$/, "");
-}
-/** True when `span` is a meaningful verbatim substring of `content`. */
-export function evidenceSpanMatches(content, span) {
-    const haystack = normalizeForMatch(content);
-    const needle = normalizeForMatch(stripEdgePunctuation(span));
-    return needle.length >= MIN_SPAN_CHARS && haystack.includes(needle);
-}
-/**
- * A `recipient_fact` / `recipient_preference` claim must not lean on a
- * counterparty statement. `observation` claims accept any speaker.
- */
-function speakerAllowedForClaim(claimType, evidence) {
-    if (claimType === "observation")
-        return true;
-    return evidence.speaker !== "counterparty";
-}
-/**
- * Verify one hypothesis. Returns the verified support (deduped) when every
- * reference resolves and satisfies the speaker constraint; otherwise null.
- */
-function verifyHypothesis(hypothesis, byId) {
-    if (hypothesis.supportRefs.length === 0)
-        return null;
-    const verified = new Map();
-    for (const ref of hypothesis.supportRefs) {
-        const evidence = byId.get(ref.evidenceId);
-        if (!evidence)
-            return null; // reference to non-allowlisted / hallucinated id
-        if (!speakerAllowedForClaim(hypothesis.claimType, evidence))
-            return null;
-        if (!evidenceSpanMatches(evidence.content, ref.span))
-            return null;
-        verified.set(evidence.evidenceId, {
-            evidenceId: evidence.evidenceId,
-            kind: evidence.kind,
-            speaker: evidence.speaker,
-            opportunityId: evidence.opportunityId,
-        });
-    }
-    return [...verified.values()];
-}
-/**
- * Verify + recurrence-gate a batch of mined hypotheses against the allowlisted
- * evidence produced for the same pass.
- */
-export function verifyHypotheses(hypotheses, evidence, minDistinctOpportunities) {
-    const byId = new Map(evidence.map((e) => [e.evidenceId, e]));
-    const retained = [];
-    let supported = 0;
-    let recurrent = 0;
-    for (const hypothesis of hypotheses) {
-        const support = verifyHypothesis(hypothesis, byId);
-        if (!support)
-            continue;
-        supported += 1;
-        const distinctOpportunities = new Set(support.map((s) => s.opportunityId)).size;
-        if (distinctOpportunities < minDistinctOpportunities)
-            continue;
-        recurrent += 1;
-        retained.push({
-            statement: hypothesis.statement,
-            claimType: hypothesis.claimType,
-            support,
-            distinctOpportunities,
-        });
-    }
-    return {
-        retained,
-        supported,
-        recurrent,
-        discarded: hypotheses.length - recurrent,
-    };
-}

package/dist/opportunities/negotiation-summary.builder.d.ts

@@ -1,37 +0,0 @@
-/**
- * Pure mappers from raw per-candidate negotiation data to the protocol's
- * `DiscoveryNegotiation` / `DiscoverySummary` shapes consumed by the question
- * generator. No DB access, no LLM — safe to import from anywhere.
- */
-import type { NegotiationTurn, NegotiationOutcome } from "../negotiations/negotiation.module.js";
-import type { DiscoveryNegotiation, DiscoverySummary } from "../shared/schemas/discovery-question.schema.js";
-/**
- * The input shape collected by the opportunity graph's negotiate node for
- * each candidate that completed a negotiation attempt (accepted, rejected,
- * stalled, or errored).
- */
-export interface NegotiationResolution {
-    candidateUserId: string;
-    /** Abstract profile slice for the LLM (e.g. "AI infra founder, Berlin"). */
-    counterpartyHint: string;
-    /** Network/community prompt for the negotiation. */
-    indexContext: string;
-    turns: NegotiationTurn[];
-    outcome: NegotiationOutcome;
-    /** Optional pre-negotiation evaluator score (0..1). */
-    seedAssessmentScore?: number;
-}
-/**
- * Convert one negotiation resolution to `DiscoveryNegotiation`.
- *
- * @param r - The raw resolution from the negotiate node.
- * @returns A `DiscoveryNegotiation` ready for the question generator.
- */
-export declare function toDiscoveryNegotiation(r: NegotiationResolution): DiscoveryNegotiation;
-/**
- * Aggregate counters across all negotiations in a single discovery turn.
- *
- * @param resolutions - All resolved negotiations from the negotiate node.
- * @returns A `DiscoverySummary` with totals and role distribution.
- */
-export declare function buildDiscoverySummary(resolutions: NegotiationResolution[]): DiscoverySummary;

package/dist/opportunities/negotiation-summary.builder.js

@@ -1,66 +0,0 @@
-/**
- * Convert one negotiation resolution to `DiscoveryNegotiation`.
- *
- * @param r - The raw resolution from the negotiate node.
- * @returns A `DiscoveryNegotiation` ready for the question generator.
- */
-export function toDiscoveryNegotiation(r) {
-    const turns = r.turns.map((t) => ({
-        action: t.action,
-        reasoning: t.assessment.reasoning,
-        suggestedRoles: {
-            ownUser: t.assessment.suggestedRoles.ownUser,
-            otherUser: t.assessment.suggestedRoles.otherUser,
-        },
-    }));
-    const outcome = {
-        hasOpportunity: r.outcome.hasOpportunity,
-        reasoning: r.outcome.reasoning,
-        ...(r.outcome.hasOpportunity && r.outcome.agreedRoles.length > 0
-            ? { agreedRoles: r.outcome.agreedRoles.map((a) => ({ userId: a.userId, role: a.role })) }
-            : {}),
-        ...(r.outcome.reason ? { reason: r.outcome.reason } : {}),
-    };
-    return {
-        counterpartyId: r.candidateUserId,
-        counterpartyHint: r.counterpartyHint,
-        indexContext: r.indexContext,
-        turns,
-        outcome,
-        ...(r.seedAssessmentScore !== undefined ? { seedAssessmentScore: r.seedAssessmentScore } : {}),
-    };
-}
-/**
- * Aggregate counters across all negotiations in a single discovery turn.
- *
- * @param resolutions - All resolved negotiations from the negotiate node.
- * @returns A `DiscoverySummary` with totals and role distribution.
- */
-export function buildDiscoverySummary(resolutions) {
-    const roleDistribution = {};
-    let opportunitiesFound = 0;
-    let noOpportunityCount = 0;
-    let timeoutCount = 0;
-    for (const r of resolutions) {
-        if (r.outcome.hasOpportunity) {
-            opportunitiesFound += 1;
-            for (const role of r.outcome.agreedRoles) {
-                const key = role.role;
-                roleDistribution[key] = (roleDistribution[key] ?? 0) + 1;
-            }
-        }
-        else {
-            noOpportunityCount += 1;
-            if (r.outcome.reason === "turn_cap" || r.outcome.reason === "timeout") {
-                timeoutCount += 1;
-            }
-        }
-    }
-    return {
-        totalCandidates: resolutions.length,
-        opportunitiesFound,
-        noOpportunityCount,
-        timeoutCount,
-        roleDistribution,
-    };
-}

package/dist/opportunities/opportunity.discovery-negotiation-summary.d.ts

@@ -1,14 +0,0 @@
-import type { NegotiationSummaryReader } from '../shared/interfaces/negotiation-summary.interface.js';
-import type { DiscoveryNegotiationDigest } from '../shared/schemas/negotiation-digest.schema.js';
-import type { DiscoveryNegotiation } from '../shared/schemas/discovery-question.schema.js';
-export interface DiscoveryNegotiationSummaryInput {
-    negotiations: DiscoveryNegotiation[];
-    summarizer: NegotiationSummaryReader | undefined;
-    callerSignal?: AbortSignal;
-}
-/**
- * Summarizes each already-admitted discovery negotiation independently. A
- * missing, null, empty, or failed model response falls back per negotiation so
- * one failure cannot suppress an ordered batch of deterministic digests.
- */
-export declare function summarizeDiscoveryNegotiations(args: DiscoveryNegotiationSummaryInput): Promise<DiscoveryNegotiationDigest[]>;

package/dist/opportunities/opportunity.discovery-negotiation-summary.js

@@ -1,46 +0,0 @@
-import { buildFallbackDigest } from '../negotiations/negotiation.module.js';
-import { protocolLogger } from '../shared/observability/protocol.logger.js';
-import { traceAgent } from '../shared/observability/trace.js';
-const logger = protocolLogger('OpportunityDiscoveryNegotiationSummary');
-const NEGOTIATION_SUMMARY_TIMEOUT_MS_DEFAULT = 5000;
-function parsePositiveIntEnv(name, fallback) {
-    const raw = process.env[name];
-    if (!raw)
-        return fallback;
-    const n = Number.parseInt(raw, 10);
-    if (!Number.isFinite(n) || n <= 0 || n > Number.MAX_SAFE_INTEGER)
-        return fallback;
-    return n;
-}
-function combineWithDeadline(callerSignal, deadlineMs) {
-    const deadline = AbortSignal.timeout(deadlineMs);
-    if (!callerSignal)
-        return deadline;
-    return AbortSignal.any([callerSignal, deadline]);
-}
-/**
- * Summarizes each already-admitted discovery negotiation independently. A
- * missing, null, empty, or failed model response falls back per negotiation so
- * one failure cannot suppress an ordered batch of deterministic digests.
- */
-export async function summarizeDiscoveryNegotiations(args) {
-    const perNegTimeoutMs = parsePositiveIntEnv('NEGOTIATION_SUMMARY_TIMEOUT_MS', NEGOTIATION_SUMMARY_TIMEOUT_MS_DEFAULT);
-    return traceAgent(`Negotiation summary (${args.negotiations.length})`, () => Promise.all(args.negotiations.map(async (negotiation) => {
-        if (!args.summarizer)
-            return buildFallbackDigest(negotiation);
-        const signal = combineWithDeadline(args.callerSignal, perNegTimeoutMs);
-        try {
-            const digest = await args.summarizer.summarize(negotiation, { signal });
-            return digest ?? buildFallbackDigest(negotiation);
-        }
-        catch (err) {
-            const aborted = err instanceof Error && err.name === 'AbortError';
-            logger.warn('negotiationSummary.summarize threw — using fallback digest', {
-                counterpartyHint: negotiation.counterpartyHint,
-                aborted,
-                error: err instanceof Error ? err.message : String(err),
-            });
-            return buildFallbackDigest(negotiation);
-        }
-    })), (digests) => `${digests.length} digest${digests.length === 1 ? '' : 's'}`);
-}

package/dist/opportunities/opportunity.enricher.d.ts

@@ -1,71 +0,0 @@
-/**
- * Opportunity enricher: when creating an opportunity, find overlapping existing
- * opportunities (by non-introducer actor userId), check semantic relatedness, and
- * optionally merge into a single enriched opportunity and expire the old one(s).
- */
-import type { CreateOpportunityData, Opportunity, OpportunityStatus } from '../shared/interfaces/database.interface.js';
-import type { Embedder } from '../shared/interfaces/embedder.interface.js';
-/**
- * Statuses excluded from the merge-candidate pool by default.
- *
- * - 'accepted': the pair already connected — do NOT fold a new discovery into
- *   the historical opp. IND-237 surfaces the existing conversation separately.
- * - 'negotiating': a negotiation is in-flight for this pair; rolling a new
- *   candidate into it would blur the outcome of the active turn. Wait for the
- *   negotiation to finalize (→ draft/pending/rejected/stalled) first, then
- *   enrichment can pick it up on the next pass.
- * - 'expired': already superseded by a later enriched opportunity. Without this
- *   exclusion, each enrichment cycle re-merges previously-expired enriched
- *   opportunities, compounding their actor arrays into 100+ entries.
- *
- * Exported for callers that want to extend rather than replace the default.
- */
-export declare const DEFAULT_ENRICHER_EXCLUDE_STATUSES: OpportunityStatus[];
-export type EnricherDatabase = {
-    findOpportunitiesByActors(actorIds: string[], options?: {
-        includeIntroducers?: boolean;
-        statuses?: OpportunityStatus[];
-        excludeStatuses?: OpportunityStatus[];
-    }): Promise<Opportunity[]>;
-};
-export type EnrichmentResult = {
-    enriched: false;
-    data: CreateOpportunityData;
-} | {
-    enriched: true;
-    data: CreateOpportunityData;
-    expiredIds: string[];
-    resolvedStatus: OpportunityStatus;
-};
-export type EnrichOrCreateOptions = {
-    similarityThreshold?: number;
-    /**
-     * Statuses to exclude from the merge-candidate pool. Defaults to
-     * {@link DEFAULT_ENRICHER_EXCLUDE_STATUSES} (`['accepted', 'negotiating']`).
-     * Pass an empty array `[]` to consider all statuses.
-     */
-    excludeStatuses?: OpportunityStatus[];
-    /** Restrict merge/expiration candidates to the authoritative owned intent. */
-    ownedIntentScope?: {
-        triggerIntentId: string;
-        ownerUserId: string;
-    };
-};
-/**
- * Enrich or create: find overlapping opportunities, filter by semantic relatedness
- * using a two-phase approach, merge actors and interpretation into a single
- * CreateOpportunityData, and return the data plus IDs to expire. If no related
- * overlap, return original data unchanged.
- *
- * Phase 1 — Intent check (free, no API call):
- *   Shared intent IDs mean the same declared user goal drove both opportunities.
- *   This is rare because the IntentReconciler already deduplicates intents per-user
- *   upstream, but when it fires it is definitive.
- *
- * Phase 2 — Batched embedding similarity (one API call for all remaining):
- *   For opportunities without shared intents, embed all reasoning texts in a single
- *   batch call and compare cosine similarity. Cross-user intent comparison (e.g.
- *   Alice's "find ML co-founder" vs Bob's "join ML startup") is implicitly handled
- *   here since reasoning text synthesizes both users' intents.
- */
-export declare function enrichOrCreate(database: EnricherDatabase, embedder: Embedder, newData: CreateOpportunityData, options?: EnrichOrCreateOptions): Promise<EnrichmentResult>;