@indexnetwork/protocol 6.12.1-rc.404.1 → 6.14.0-rc.406.1

package/dist/opportunity/domain/opportunity.actor.js

@@ -0,0 +1,39 @@
+/**
+ * Normalize an actor intent value while preserving protocol string IDs.
+ * Null-like model sentinels are represented by absence in persisted actors.
+ */
+export function normalizeOpportunityActorIntent(value) {
+    if (typeof value !== 'string')
+        return undefined;
+    const normalized = value.trim();
+    if (normalized.length === 0
+        || normalized.toLowerCase() === 'null'
+        || normalized.toLowerCase() === 'undefined') {
+        return undefined;
+    }
+    return normalized;
+}
+/** Resolve the normalized intent from either evaluator or persisted actor fields. */
+export function resolveOpportunityActorIntent(actor) {
+    return normalizeOpportunityActorIntent(actor.intentId)
+        ?? normalizeOpportunityActorIntent(actor.intent);
+}
+/** Return a non-mutating actor copy with a canonical optional intent. */
+export function normalizeOpportunityActors(actors) {
+    return actors.map((actor) => {
+        const normalizedActor = { ...actor };
+        const normalizedIntent = normalizeOpportunityActorIntent(actor.intent);
+        delete normalizedActor.intent;
+        if (normalizedIntent !== undefined) {
+            normalizedActor.intent = normalizedIntent;
+        }
+        return normalizedActor;
+    });
+}
+/** Return non-mutating create data whose actor intents are canonical. */
+export function normalizeCreateOpportunityActorIntents(data) {
+    return {
+        ...data,
+        actors: normalizeOpportunityActors(data.actors),
+    };
+}

package/dist/opportunity/domain/opportunity.claim-safety.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Deterministic guard for unsupported person-affiliation and presence claims.
+ *
+ * Opportunity presentation contracts currently do not carry typed provenance
+ * proving attendance, membership, residence, or shared presence. The guard
+ * therefore fails closed: a sentence making one of those claims is rejected
+ * rather than loosely "grounded" against network/context text.
+ *
+ * The patterns are deliberately phrase-based. They target factual claims such
+ * as "Alice is a member of..." while leaving generic domain phrases such as
+ * "membership model" and "team members" alone. This is not a general factuality
+ * checker and does not attempt semantic inference beyond the listed claim
+ * families.
+ */
+/** Returns true when text contains an unsupported affiliation/presence claim. */
+export declare function hasUnsupportedOpportunityClaim(text: string | null | undefined): boolean;
+/** Returns true when one sentence contains an unsupported claim family. */
+export declare function isUnsupportedOpportunityClaimSentence(sentence: string): boolean;
+/**
+ * Removes complete sentences containing unsupported claims and preserves the
+ * remaining sentence order. An all-unsafe input becomes an empty string so the
+ * caller can apply a field-specific deterministic default.
+ */
+export declare function stripUnsupportedOpportunityClaims(text: string | null | undefined): string;

package/dist/opportunity/domain/opportunity.claim-safety.js

@@ -0,0 +1,88 @@
+/**
+ * Deterministic guard for unsupported person-affiliation and presence claims.
+ *
+ * Opportunity presentation contracts currently do not carry typed provenance
+ * proving attendance, membership, residence, or shared presence. The guard
+ * therefore fails closed: a sentence making one of those claims is rejected
+ * rather than loosely "grounded" against network/context text.
+ *
+ * The patterns are deliberately phrase-based. They target factual claims such
+ * as "Alice is a member of..." while leaving generic domain phrases such as
+ * "membership model" and "team members" alone. This is not a general factuality
+ * checker and does not attempt semantic inference beyond the listed claim
+ * families.
+ */
+const UNSUPPORTED_CLAIM_PATTERNS = [
+    // Attendance and co-attendance claims. Relational grammar avoids product
+    // phrases such as "attendee management".
+    /\b(?:co[-\s]?attendance|co[-\s]?attendee(?:s)?|co[-\s]?attend(?:ed|ing)?|(?:another|fellow)\s+(?:(?:event|session|conference|summit|gathering|meetup)\s+)?attendees?)\b/i,
+    /\b(?:is|are|was|were|will be|has been|have been|as)\s+(?:an?\s+)?attendees?\b/i,
+    /\b(?:a|an|this|that)\s+attendee\s+(?:of|at)\b/i,
+    /\b(?:will\s+|plans?\s+to\s+)?attend(?:ed|ing)?\s+(?!to\b)(?:(?:at|in)\s+)?(?:the\s+)?[\p{L}\p{N}&'’.-]+\b/iu,
+    /\b(?:is|are|was|were|will be)\s+going\s+to\s+(?:the\s+)?(?:event|session|conference|summit|gathering|meetup|[A-Z][\p{L}\p{N}&'’.-]*)\b/u,
+    /\b(?:[Pp]articipat(?:ed|ing)|[Pp]articipants?)\b(?=.{0,40}\b(?:in|at)\s+(?:the\s+)?(?:event|session|conference|summit|gathering|meetup|[A-Z][\p{L}\p{N}&'’.-]*))/u,
+    /\b(?:[Ww]ent\s+to|[Tt]ook\s+part\s+in|(?:[Ww]as|[Ww]ere|[Ii]s|[Aa]re)\s+present\s+at)\s+(?:the\s+)?(?:event|session|conference|summit|gathering|meetup|[A-Z][\p{L}\p{N}&'’.-]*)\b/u,
+    /\b(?:session\s+attendance|attendance\s+(?:at|in)\s+(?:the\s+)?(?:event|session|conference|summit|gathering|meetup))\b/i,
+    // Shared event/session/place/time claims, including "both were at ...".
+    /\b(?:same|the same)\s+(?:event|session|place|location|venue|time)\b/i,
+    /\b(?:share|shared|sharing)\s+(?:an?\s+|the\s+)?(?:event|session|workshop|conference|summit|gathering|meetup|place|location|venue|time)\b/i,
+    /\bboth\s+(?:were|are|will be|have been)\s+(?:at|in|during)\b/i,
+    /\b(?:were|are|will be|have been)\s+both\s+(?:at|in|during)\b/i,
+    /\b(?:will|would|are|were)\s+both\s+be?\s*(?:at|in|during)\b/i,
+    /\bboth\b.{0,80}\b(?:attend(?:ed|ing)?|participat(?:e|ed|ing)|met|meet|meeting|stayed|stay)\b.{0,60}\b(?:event|session|place|location|venue|time)\b/i,
+    // Factual membership/affiliation claims. Generic descriptions of product
+    // users ("members of cooperatives") and "team members" stay untouched.
+    /\b(?:is|are|was|were|be|being|been|became|become|as)\s+(?:an?\s+)?(?:fellow\s+)?members?\s+(?:of|in)\b/i,
+    /\b(?:another|fellow)\s+members?\b/i,
+    /\b(?:is|are|was|were|be|being|been|as)\s+(?:an?\s+)?(?:community|network|event)\s+members?\b/i,
+    /\b(?:a|an|this|that)\s+(?:fellow\s+)?member\s+(?:of|in)\b/i,
+    /\b(?:is|are|was|were|be|being|been)\s+(?:an?\s+)?part\s+of\s+(?:the\s+)?[^.!?]{0,60}\b(?:community|network|event)\b/i,
+    /\bfellow\s+members?\s+(?:of|in)\b/i,
+    /\b(?:a|an)\s+(?:[A-Z][\p{L}\p{N}&'’.-]*\s+){1,6}(?:community\s+|network\s+)?member\b/u,
+    /\b(?:[Bb]elongs?|[Bb]elonged)\s+to\s+(?:the\s+)?(?:[Nn]etwork|[Cc]ommunity|[Ee]vent|(?:[A-Z][\p{L}\p{N}&'’.-]*\s+){1,5}[A-Z][\p{L}\p{N}&'’.-]*)\b/u,
+    /\b[Jj]oined\s+(?:the\s+)?(?:[Nn]etwork|[Cc]ommunity|[Ee]vent|(?:[A-Z][\p{L}\p{N}&'’.-]*\s+){1,5}[A-Z][\p{L}\p{N}&'’.-]*)\b/u,
+    /\b[Aa]ffiliated\s+with\s+(?:the\s+)?(?:[Nn]etwork|[Cc]ommunity|[Ee]vent|[A-Z][\p{L}\p{N}&'’.-]*)\b/u,
+    // Residence/co-residence claims. Require person-claim grammar so generic
+    // audience descriptions such as "tools for residents of Berlin" survive.
+    /\b(?:is|are|was|were|be|being|been|as)\s+(?:an?\s+)?(?:local\s+|long[-\s]?time\s+|co[-\s]?)?residents?\b/i,
+    /\bco[-\s]?(?:reside|resides|resided|residing)\b/i,
+    /\b(?:another|fellow)\s+residents?\b/i,
+    /\b(?:a|an|this|that)\s+(?:co[-\s]?)?resident\s+(?:of|in)\b/i,
+    /\b(?:a|an)\s+(?:[A-Z][\p{L}\p{N}&'’.-]*\s+){1,6}(?:co[-\s]?)?resident\b/u,
+    /\b(?:[Hh]e|[Ss]he|[Tt]hey|[A-Z][\p{L}'’.-]+)\s+(?:reside|resides|resided|residing|live|lives|lived|living|(?:is|are|was|were)\s+based)\s+in\b/u,
+    /\b(?:[Hh]e|[Ss]he|[Tt]hey|[A-Z][\p{L}'’.-]+)\s+calls?\s+[A-Z][\p{L}\p{N}&'’.-]*(?:\s+[A-Z][\p{L}\p{N}&'’.-]*){0,5}\s+home\b/u,
+    // Relationship claims inferred from shared network/event placement.
+    /\b(?:know|knows|knew|met|meet)\b.{0,60}\b(?:through|from|at)\s+(?:the\s+)?(?:network|community|event|session)\b/i,
+    /\bcrossed\s+paths\s+(?:at|during)\b/i,
+];
+/** Returns true when text contains an unsupported affiliation/presence claim. */
+export function hasUnsupportedOpportunityClaim(text) {
+    if (!text?.trim())
+        return false;
+    return splitClaimSentences(text).some(isUnsupportedOpportunityClaimSentence);
+}
+/** Returns true when one sentence contains an unsupported claim family. */
+export function isUnsupportedOpportunityClaimSentence(sentence) {
+    return UNSUPPORTED_CLAIM_PATTERNS.some((pattern) => pattern.test(sentence));
+}
+/**
+ * Removes complete sentences containing unsupported claims and preserves the
+ * remaining sentence order. An all-unsafe input becomes an empty string so the
+ * caller can apply a field-specific deterministic default.
+ */
+export function stripUnsupportedOpportunityClaims(text) {
+    if (!text?.trim())
+        return "";
+    return splitClaimSentences(text)
+        .filter((sentence) => !isUnsupportedOpportunityClaimSentence(sentence))
+        .join(" ")
+        .replace(/\s+/g, " ")
+        .trim();
+}
+function splitClaimSentences(text) {
+    return text
+        .trim()
+        .split(/(?<=[.!?])\s+|\n+/)
+        .map((sentence) => sentence.trim())
+        .filter(Boolean);
+}

package/dist/opportunity/domain/opportunity.discovery-run-coalescing.d.ts

@@ -0,0 +1,33 @@
+type DiscoveryRunScope = {
+    scopeType?: string;
+    scopeId?: string;
+};
+type DiscoveryCoalescingRequest = {
+    continueFrom?: string;
+    searchQuery?: string;
+    networkId?: string;
+    intentId?: string;
+    targetUserId?: string;
+    introTargetUserId?: string;
+    partyUserIds?: string[];
+    entities?: Array<{
+        userId: string;
+        networkId: string;
+    }>;
+    hint?: string;
+};
+type ActiveDiscoveryRunForCoalescing = {
+    id: string;
+    status: string;
+    input: DiscoveryCoalescingRequest;
+    context: DiscoveryRunScope;
+};
+/**
+ * Finds an active MCP discovery run that describes the same user request and
+ * resolved scope boundary. The identity is deliberately normalized so harmless
+ * formatting differences share one expensive graph execution, while distinct
+ * hints, opaque continuation tokens, entity networks, and scopes remain
+ * independent runs.
+ */
+export declare function findCoalescedDiscoveryRun(input: DiscoveryCoalescingRequest, context: DiscoveryRunScope, activeRuns: readonly ActiveDiscoveryRunForCoalescing[]): ActiveDiscoveryRunForCoalescing | undefined;
+export {};

package/dist/opportunity/domain/opportunity.discovery-run-coalescing.js

@@ -0,0 +1,33 @@
+/**
+ * Finds an active MCP discovery run that describes the same user request and
+ * resolved scope boundary. The identity is deliberately normalized so harmless
+ * formatting differences share one expensive graph execution, while distinct
+ * hints, opaque continuation tokens, entity networks, and scopes remain
+ * independent runs.
+ */
+export function findCoalescedDiscoveryRun(input, context, activeRuns) {
+    const signature = discoveryRunSignature(input, context);
+    return activeRuns.find((run) => discoveryRunSignature(run.input, run.context) === signature);
+}
+function discoveryRunSignature(input, scope) {
+    const text = (value) => (value ?? "").trim().toLowerCase();
+    const id = (value) => (value ?? "").trim();
+    const entities = [...(input.entities ?? [])]
+        .map((entity) => JSON.stringify([id(entity.networkId), id(entity.userId)]))
+        .sort();
+    return JSON.stringify({
+        searchQuery: text(input.searchQuery),
+        networkId: id(input.networkId),
+        intentId: id(input.intentId),
+        targetUserId: id(input.targetUserId),
+        introTargetUserId: id(input.introTargetUserId),
+        continueFrom: id(input.continueFrom),
+        hint: text(input.hint),
+        partyUserIds: [...(input.partyUserIds ?? [])].map((value) => value.trim()).sort(),
+        entities,
+        scope: {
+            scopeType: id(scope.scopeType),
+            scopeId: id(scope.scopeId),
+        },
+    });
+}

package/dist/opportunity/domain/opportunity.discovery.contracts.d.ts

@@ -0,0 +1,45 @@
+import type { Question, QuestionStrategy } from "../../shared/schemas/question.schema.js";
+/** One step for discovery debug visibility (subgraph/subtask). */
+export interface DiscoverDebugStep {
+    step: string;
+    detail?: string;
+    data?: Record<string, unknown>;
+}
+/** Neutral discovery result envelope shared with continuation finalization. */
+export interface DiscoveryResultContract<TOpportunity> {
+    found: boolean;
+    count: number;
+    message?: string;
+    opportunities?: TOpportunity[];
+    existingConnections?: Array<{
+        userId: string;
+        name: string;
+        status?: string;
+        opportunityId?: string;
+    }>;
+    existingConnectionsForMention?: Array<{
+        userId: string;
+        name: string;
+        status?: string;
+        opportunityId?: string;
+    }>;
+    alreadyAcceptedPairs?: Array<{
+        opportunityId: string;
+        counterpartyUserId: string;
+    }>;
+    createIntentSuggested?: boolean;
+    suggestedIntentDescription?: string;
+    debugSteps?: DiscoverDebugStep[];
+    pagination?: {
+        discoveryId: string;
+        evaluated: number;
+        remaining: number;
+    };
+    questions?: Question[];
+    discoveryQuestionsDebug?: {
+        inputMode: "transcripts" | "insights";
+        finalCount: number;
+        strategies: QuestionStrategy[];
+        durationMs: number;
+    };
+}

package/dist/opportunity/domain/opportunity.discovery.contracts.js

@@ -0,0 +1 @@
+export {};

package/dist/opportunity/domain/opportunity.evidence.d.ts

@@ -0,0 +1,21 @@
+import type { OpportunityEvidence } from '../../shared/schemas/network-assignment.schema.js';
+export interface EvidenceCandidateInput {
+    networkId: string;
+    similarity: number;
+    lens: string;
+    discoverySource?: 'query' | 'premise-similarity' | 'context-to-intent';
+    matchedStrategies?: string[];
+    sourcePremiseId?: string;
+    candidatePremiseId?: string;
+    candidateIntentId?: string;
+    sourceContextId?: string;
+    candidatePayload?: string;
+    candidateSummary?: string;
+}
+export declare function buildCandidateEvidence(candidate: EvidenceCandidateInput): OpportunityEvidence;
+export declare function withCandidateEvidence<T extends EvidenceCandidateInput>(candidate: T): T & {
+    evidence: OpportunityEvidence[];
+};
+export declare function mergeOpportunityEvidence(...groups: Array<OpportunityEvidence[] | undefined>): OpportunityEvidence[];
+export declare function withMatchedStrategies(evidence: OpportunityEvidence[], strategies: string[]): OpportunityEvidence[];
+export declare function renderOpportunityEvidenceForPrompt(evidence: OpportunityEvidence[]): string;

package/dist/opportunity/domain/opportunity.evidence.js

@@ -0,0 +1,78 @@
+export function buildCandidateEvidence(candidate) {
+    const kind = resolveEvidenceKind(candidate);
+    return {
+        kind,
+        networkId: candidate.networkId,
+        score: candidate.similarity,
+        lens: candidate.lens,
+        discoverySource: candidate.discoverySource,
+        matchedStrategies: candidate.matchedStrategies,
+        sourcePremiseId: candidate.sourcePremiseId,
+        candidatePremiseId: candidate.candidatePremiseId,
+        candidateIntentId: candidate.candidateIntentId,
+        sourceContextId: candidate.sourceContextId,
+        payload: candidate.candidatePayload,
+        summary: candidate.candidateSummary,
+        assertionText: candidate.candidatePremiseId ? candidate.candidatePayload : undefined,
+    };
+}
+export function withCandidateEvidence(candidate) {
+    return { ...candidate, evidence: [buildCandidateEvidence(candidate)] };
+}
+export function mergeOpportunityEvidence(...groups) {
+    const byKey = new Map();
+    for (const evidence of groups.flatMap((group) => group ?? [])) {
+        const key = [
+            evidence.kind,
+            evidence.networkId,
+            evidence.sourcePremiseId ?? '',
+            evidence.candidatePremiseId ?? '',
+            evidence.candidateIntentId ?? '',
+            evidence.sourceContextId ?? '',
+            evidence.lens ?? '',
+        ].join('|');
+        const existing = byKey.get(key);
+        if (!existing || (evidence.score ?? 0) > (existing.score ?? 0))
+            byKey.set(key, evidence);
+    }
+    return Array.from(byKey.values());
+}
+export function withMatchedStrategies(evidence, strategies) {
+    return evidence.map((item) => ({
+        ...item,
+        matchedStrategies: Array.from(new Set([...(item.matchedStrategies ?? []), ...strategies])),
+    }));
+}
+export function renderOpportunityEvidenceForPrompt(evidence) {
+    if (evidence.length === 0)
+        return '    —';
+    return evidence.map((item) => {
+        const refs = [
+            item.sourcePremiseId ? `sourcePremise=${item.sourcePremiseId}` : undefined,
+            item.candidatePremiseId ? `candidatePremise=${item.candidatePremiseId}` : undefined,
+            item.candidateIntentId ? `candidateIntent=${item.candidateIntentId}` : undefined,
+            item.sourceContextId ? `sourceContext=${item.sourceContextId}` : undefined,
+            item.matchedStrategies?.length ? `strategies=${item.matchedStrategies.join(',')}` : undefined,
+        ].filter(Boolean).join(', ');
+        const text = item.summary ?? item.payload ?? item.assertionText ?? '';
+        // IND-567 Fix B: when a query_premise entry has no text, warn the evaluator
+        // so it does not treat a high RAG score as domain confirmation.
+        // (text should be populated by Fix A; this fallback fires if the DB fetch
+        //  failed or the adapter omitted getPremise).
+        const domainCaution = item.kind === 'query_premise' && !text
+            ? ' [premise text unavailable — do NOT infer domain match from RAG score alone; verify domain alignment from profile]'
+            : '';
+        return `    - ${item.kind} on ${item.networkId} via ${item.lens ?? 'unknown'} score=${item.score?.toFixed(3) ?? '—'}${refs ? ` (${refs})` : ''}${text ? `: ${text}` : ''}${domainCaution}`;
+    }).join('\n');
+}
+function resolveEvidenceKind(candidate) {
+    if (candidate.discoverySource === 'premise-similarity')
+        return 'premise_similarity';
+    if (candidate.discoverySource === 'context-to-intent')
+        return 'context_to_intent';
+    if (candidate.candidatePremiseId)
+        return 'query_premise';
+    if (candidate.candidateIntentId)
+        return 'query_intent';
+    return 'profile';
+}

package/dist/opportunity/domain/opportunity.labels.d.ts

@@ -0,0 +1,8 @@
+/** Max chars for main text in minimal opportunity cards (chat tool payload). Full text shown so cards are not truncated. */
+export declare const MINIMAL_MAIN_TEXT_MAX_CHARS = 2000;
+/** Hardcoded button labels for opportunity cards (not LLM-generated). */
+export declare const PRIMARY_ACTION_LABEL_INTRODUCER = "Good match";
+export declare const PRIMARY_ACTION_LABEL_DEFAULT = "Start Chat";
+export declare const SECONDARY_ACTION_LABEL = "Skip";
+/** Returns the primary action label based on the viewer's role. */
+export declare function getPrimaryActionLabel(viewerRole: string): string;

package/dist/opportunity/domain/opportunity.labels.js

@@ -0,0 +1,10 @@
+/** Max chars for main text in minimal opportunity cards (chat tool payload). Full text shown so cards are not truncated. */
+export const MINIMAL_MAIN_TEXT_MAX_CHARS = 2000;
+/** Hardcoded button labels for opportunity cards (not LLM-generated). */
+export const PRIMARY_ACTION_LABEL_INTRODUCER = "Good match";
+export const PRIMARY_ACTION_LABEL_DEFAULT = "Start Chat";
+export const SECONDARY_ACTION_LABEL = "Skip";
+/** Returns the primary action label based on the viewer's role. */
+export function getPrimaryActionLabel(viewerRole) {
+    return viewerRole === "introducer" ? PRIMARY_ACTION_LABEL_INTRODUCER : PRIMARY_ACTION_LABEL_DEFAULT;
+}

package/dist/opportunity/domain/opportunity.presentation-cache.d.ts

@@ -0,0 +1,6 @@
+/** Cache namespace for opportunity presentation copy. Bump to invalidate copy safety changes. */
+export declare const OPPORTUNITY_PRESENTATION_CACHE_VERSION = "v2";
+export declare function buildHomeCardPresentationCacheKey(opportunityId: string, status: string, viewerId: string): string;
+export declare function buildHomeCategoryPresentationCacheKey(viewerId: string, opportunitySetHash: string): string;
+export declare function buildDeliveryCardPresentationCacheKey(opportunityId: string, status: string, viewerId: string): string;
+export declare function buildApiChatCardPresentationCacheKey(opportunityId: string, viewerId: string): string;

package/dist/opportunity/domain/opportunity.presentation-cache.js

@@ -0,0 +1,14 @@
+/** Cache namespace for opportunity presentation copy. Bump to invalidate copy safety changes. */
+export const OPPORTUNITY_PRESENTATION_CACHE_VERSION = "v2";
+export function buildHomeCardPresentationCacheKey(opportunityId, status, viewerId) {
+    return `home:${OPPORTUNITY_PRESENTATION_CACHE_VERSION}:card:${opportunityId}:${status}:${viewerId}`;
+}
+export function buildHomeCategoryPresentationCacheKey(viewerId, opportunitySetHash) {
+    return `home:${OPPORTUNITY_PRESENTATION_CACHE_VERSION}:categories:${viewerId}:${opportunitySetHash}`;
+}
+export function buildDeliveryCardPresentationCacheKey(opportunityId, status, viewerId) {
+    return `delivery:${OPPORTUNITY_PRESENTATION_CACHE_VERSION}:card:${opportunityId}:${status}:${viewerId}`;
+}
+export function buildApiChatCardPresentationCacheKey(opportunityId, viewerId) {
+    return `chat:${OPPORTUNITY_PRESENTATION_CACHE_VERSION}:card:${opportunityId}:${viewerId}`;
+}

package/dist/opportunity/domain/opportunity.presentation.d.ts

@@ -0,0 +1,76 @@
+/**
+ * Pure presentation layer for opportunities.
+ * Generates title, description, and CTA based on viewer context — no DB access.
+ */
+import type { Opportunity } from '../../shared/interfaces/database.interface.js';
+export interface OpportunityPresentation {
+    title: string;
+    description: string;
+    callToAction: string;
+}
+export interface UserInfo {
+    id: string;
+    name: string;
+    avatar: string | null;
+}
+/**
+ * Generate presentation copy for an opportunity based on viewer context.
+ * Pure function — no side effects, no database access.
+ */
+export declare function presentOpportunity(opp: Opportunity, viewerId: string, otherPartyInfo: UserInfo, introducerInfo: UserInfo | null, format: 'card' | 'email' | 'notification'): OpportunityPresentation;
+export declare function stripUuids(text: string): string;
+/**
+ * Truncate user-facing text to at most `maxChars` without cutting mid-word.
+ *
+ * Prefers a sentence boundary, then a word boundary, and only falls back to a
+ * hard slice if no boundary exists within the limit. An ellipsis is appended
+ * when the text is actually shortened. Used by presenter fallbacks so a degraded
+ * card never shows a sentence chopped mid-word (e.g. "His focus on 'indiv").
+ */
+export declare function truncateAtBoundary(text: string, maxChars: number): string;
+/**
+ * Strips introducer mentions from opportunity summary text.
+ * Removes patterns like:
+ * - "[Introducer] introduced you to [Counterpart]"
+ * - "[Introducer] thinks you should meet [Counterpart]"
+ * - "[Introducer] connected you to [Counterpart]"
+ * - "[Introducer] suggested you meet [Counterpart]"
+ *
+ * @param text - The text to clean (personalizedSummary)
+ * @param introducerName - Full name of the introducer to strip
+ * @returns Text with introducer mentions removed, counterpart preserved
+ */
+export declare function stripIntroducerMentions(text: string, introducerName: string | undefined): string;
+/**
+ * Returns viewer-centric main text for an opportunity card.
+ * Prefers the part of the reasoning that describes the counterpart (the person
+ * on the card), so the viewer sees an introduction to the counterpart rather
+ * than a description of themselves.
+ *
+ * @param reasoning - Raw interpretation.reasoning (may describe both parties).
+ * @param counterpartName - Display name of the suggested connection (e.g. "Alex Chen").
+ * @param maxChars - Max length of returned string (default MINIMAL_MAIN_TEXT_MAX_CHARS).
+ * @param viewerName - Optional display name of the viewer (signed-in user). When provided, sentences or prefixes describing the viewer are skipped so the card introduces the counterpart, not the viewer.
+ * @param introducerName - Optional display name of the introducer. When provided, introducer phrases (e.g., "X introduced you to...") are stripped from the summary to keep the body text focused on match quality.
+ * @returns Viewer-centric snippet mentioning the counterpart when possible; if counterpartName is empty, returns reasoning truncated to maxChars. Never null; may be "A suggested connection." when reasoning is empty.
+ */
+export declare function viewerCentricCardSummary(reasoning: string, counterpartName: string, maxChars?: number, viewerName?: string, introducerName?: string): string;
+/**
+ * Generates a short narrator remark from opportunity reasoning for the narrator chip.
+ * Used by the minimal (no-LLM) card path so each card gets a unique remark
+ * instead of the same static text.
+ *
+ * Extracts domain keywords (e.g. "AI", "design", "machine learning") from the
+ * reasoning and frames them in a short template like "Shared interest in AI and design."
+ *
+ * This is a regex-based heuristic — an alternative is OpportunityPresenter.presentHomeCard()
+ * which generates narratorRemark via LLM with much higher quality (already used by
+ * home.graph.ts and opportunity.discover.ts). See buildMinimalOpportunityCard() in
+ * opportunity.tools.ts for the trade-off discussion.
+ *
+ * @param reasoning - Raw interpretation.reasoning text.
+ * @param counterpartName - Display name of the counterpart (stripped from output).
+ * @param viewerName - Optional display name of the viewer (stripped from output).
+ * @returns A short remark (max ~80 chars) suitable for the narrator chip. Never truncated with "...".
+ */
+export declare function narratorRemarkFromReasoning(reasoning: string, counterpartName: string, viewerName?: string): string;