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

package/dist/opportunity/application/opportunity.graph.js

@@ -0,0 +1,3707 @@
+/**
+ * Opportunity Graph: Linear Multi-Step Workflow for Opportunity Discovery
+ *
+ * Architecture: Follows intent graph pattern with Annotation-based state.
+ * Flow: Prep → Scope → Discovery → Evaluation → Ranking → Persist → END
+ *
+ * Key Constraints:
+ * - Opportunities only between intents sharing the same index
+ * - Both intents must have hyde documents for semantic matching
+ * - Non-indexed intents cannot participate in discovery
+ *
+ * Constructor injects Database, Embedder, and compiled HyDE graph.
+ */
+import { StateGraph, START, END } from '@langchain/langgraph';
+import { OpportunityGraphState } from '../domain/opportunity.state.js';
+import { resolveInitialStatus } from '../domain/opportunity.state.js';
+import { OpportunityEvaluator } from './opportunity.evaluator.js';
+import { IntentIndexer } from '../../capabilities/signals.indexing.facade.js';
+import { getModelName } from '../../shared/agent/model.config.js';
+import { selectHydeDocumentsForGeneration } from '../../shared/hyde/hyde.documents.js';
+import { getHydeGenerationMode } from '../../shared/hyde/hyde.env.js';
+import { validateOpportunityActors } from '../domain/opportunity.utils.js';
+import { safeFallbackSummary } from '../domain/opportunity.safe-presentation.js';
+import { hasUnsupportedOpportunityClaim } from '../domain/opportunity.claim-safety.js';
+import { persistOpportunities } from './opportunity.persist.js';
+import { INTRODUCER_DISCOVERY_SOURCE } from './opportunity.introducer.js';
+import { negotiateCandidates, ASK_USER_LOCK_SLACK_MS, askUserAnswerWindowMs, AMBIENT_PARK_WINDOW_MS } from "../../capabilities/negotiation.discovery.facade.js";
+import { buildDiscoverySummary, toDiscoveryNegotiation } from "../domain/negotiation-summary.builder.js";
+import { protocolLogger, withCallLogging } from '../../shared/observability/protocol.logger.js';
+import { timed } from '../../shared/observability/performance.js';
+import { renderNetworkContext } from '../../shared/network/metadata.renderer.js';
+import { requestContext } from "../../shared/observability/request-context.js";
+import { mergeOpportunityEvidence, withCandidateEvidence, withMatchedStrategies } from '../domain/opportunity.evidence.js';
+import { normalizeOpportunityActorIntent, resolveOpportunityActorIntent } from '../domain/opportunity.actor.js';
+import { approveOpportunityIntroduction, deleteOpportunityLifecycle, sendOpportunityLifecycle, updateOpportunityLifecycle } from './opportunity.lifecycle.js';
+import { stampEligibleNewbornOpportunities } from './opportunity.newborn-stamping.js';
+import { buildPrioritizedNegotiationIntents, negotiateExistingOpportunity, negotiationIncludesOtherIntents } from './opportunity.existing-negotiation.js';
+import { admitOpportunityPersistence, createEligibleOpportunityStatusUpdater } from './opportunity.persistence-admission.js';
+export { buildPrioritizedNegotiationIntents } from './opportunity.existing-negotiation.js';
+const logger = protocolLogger('OpportunityGraph');
+const prepLog = protocolLogger('OpportunityGraph:Prep');
+const scopeLog = protocolLogger('OpportunityGraph:Scope');
+const resolveLog = protocolLogger('OpportunityGraph:Resolve');
+const discoveryLog = protocolLogger('OpportunityGraph:Discovery');
+const evaluationLog = protocolLogger('OpportunityGraph:Evaluation');
+const negotiateLog = protocolLogger('OpportunityGraph:Negotiate');
+const rankingLog = protocolLogger('OpportunityGraph:Ranking');
+const introValidationLog = protocolLogger('OpportunityGraph:IntroValidation');
+const introEvaluationLog = protocolLogger('OpportunityGraph:IntroEvaluation');
+const persistLog = protocolLogger('OpportunityGraph:Persist');
+const persistPathLog = protocolLogger('OpportunityGraph:Persist:PathSelect');
+const persistDedupLog = protocolLogger('OpportunityGraph:Persist:Dedup');
+const readLog = protocolLogger('OpportunityGraph:Read');
+const updateLog = protocolLogger('OpportunityGraph:Update');
+const deleteLog = protocolLogger('OpportunityGraph:Delete');
+const sendLog = protocolLogger('OpportunityGraph:Send');
+const negotiateExistingLog = protocolLogger('OpportunityGraph:NegotiateExisting');
+const routingLog = protocolLogger('OpportunityGraph:Routing');
+/** Time window for persist-node dedup. Suppresses a second opportunity with the same person while a recent one (within 30 days) is still in flight, so a person is not re-surfaced multiple times within a month (EDG-23). */
+const DEDUP_WINDOW_MS = 30 * 24 * 60 * 60 * 1000;
+const ACTIVE_NEGOTIATION_TASK_STATES = new Set([
+    'submitted',
+    'working',
+    'input_required',
+    'waiting_for_agent',
+    'claimed',
+]);
+function isActiveNegotiationTaskFresh(task) {
+    if (!ACTIVE_NEGOTIATION_TASK_STATES.has(task.state))
+        return false;
+    const freshnessMs = task.state === 'input_required'
+        ? askUserAnswerWindowMs() + ASK_USER_LOCK_SLACK_MS
+        : 5 * 60 * 1000;
+    return Date.now() - new Date(task.updatedAt).getTime() < freshnessMs;
+}
+function triggerForOwner(opportunity, ownerUserId) {
+    return opportunity.detection.triggeredBy
+        ?? opportunity.actors.find((actor) => actor.userId === ownerUserId)?.intent;
+}
+function belongsToOwnedIntent(opportunity, ownerUserId, triggerIntentId) {
+    return opportunity.detection.triggeredBy === triggerIntentId
+        || opportunity.actors.some((actor) => actor.userId === ownerUserId && actor.intent === triggerIntentId);
+}
+/**
+ * IND-567: Cool-down window (ms) for cross-query rejection suppression.
+ * Candidates with a recently rejected or stalled opportunity within this window
+ * receive a similarity penalty during evaluation ranking. Default 7 days.
+ * Override with DISCOVERY_REJECTION_COOLDOWN_DAYS (positive float).
+ */
+const DEFAULT_REJECTION_COOLDOWN_MS = 7 * 24 * 60 * 60 * 1000;
+function getRejectionCooldownMs() {
+    const raw = process.env.DISCOVERY_REJECTION_COOLDOWN_DAYS;
+    if (!raw)
+        return DEFAULT_REJECTION_COOLDOWN_MS;
+    const n = Number.parseFloat(raw);
+    return Number.isFinite(n) && n > 0 ? Math.round(n * 24 * 60 * 60 * 1000) : DEFAULT_REJECTION_COOLDOWN_MS;
+}
+/**
+ * Similarity multiplier applied to candidates that fall within the rejection
+ * cool-down window (IND-567). 0.5 halves their ranking score, typically
+ * pushing them below the evaluation-batch cut while leaving a soft trace in
+ * the trace log rather than silently dropping them.
+ */
+const REJECTION_COOLDOWN_SIMILARITY_PENALTY = 0.5;
+/** Default cap for source premises used by premise-to-premise discovery. Prevents BACKEND-5-style fan-out. */
+const DEFAULT_SOURCE_PREMISE_DISCOVERY_LIMIT = 40;
+function networkMembershipPairKey(userId, networkId) {
+    return `${userId}\u0000${networkId}`;
+}
+/** Per-source cap for candidate premise matches. */
+const PREMISE_MATCH_LIMIT_PER_SOURCE = 20;
+/** Resolve the source premise discovery cap from env, preserving 0 as an explicit disable switch. */
+function getSourcePremiseDiscoveryLimit() {
+    const raw = process.env.DISCOVERY_SOURCE_PREMISE_LIMIT;
+    if (raw === undefined || raw.trim() === '')
+        return DEFAULT_SOURCE_PREMISE_DISCOVERY_LIMIT;
+    const parsed = Number.parseInt(raw, 10);
+    return Number.isFinite(parsed) && parsed >= 0 ? parsed : DEFAULT_SOURCE_PREMISE_DISCOVERY_LIMIT;
+}
+function buildEvaluatorEvidenceKey(candidate) {
+    return [
+        candidate.candidateUserId,
+        candidate.networkId,
+        candidate.candidateIntentId ?? candidate.candidatePremiseId ?? candidate.sourceContextId ?? 'profile',
+    ].join(':');
+}
+/**
+ * Builds a compact text summary of the discoverer's profile and active intents
+ * for use as profileContext in HyDE generation.
+ * @param profile - The discoverer's profile data (identity, attributes)
+ * @param intents - The discoverer's indexed intents (capped at 5)
+ * @returns A context string, or undefined if no meaningful data is available
+ */
+export function buildDiscovererContext(profile, intents) {
+    const lines = [];
+    if (profile) {
+        const identity = profile.identity;
+        if (identity?.name || identity?.bio) {
+            lines.push(`Profile: ${[identity.name, identity.bio].filter(Boolean).join(', ')}`);
+        }
+        if (identity?.location) {
+            lines.push(`Location: ${identity.location}`);
+        }
+        if (profile.context) {
+            lines.push(`Context: ${profile.context}`);
+        }
+    }
+    if (intents?.length) {
+        // indexedIntents preserves DB order from getActiveIntents (newest first),
+        // so slice(0, 5) is deterministic without an explicit sort.
+        const capped = intents.slice(0, 5);
+        lines.push('');
+        lines.push('Active intents:');
+        for (const intent of capped) {
+            lines.push(`- ${intent.payload}`);
+        }
+    }
+    return lines.length > 0 ? lines.join('\n') : undefined;
+}
+/**
+ * Build a networkContexts map for the evaluator from a set of entities.
+ * Fetches network data, checks permissions.contextInjection.discovery,
+ * and renders context for eligible networks.
+ */
+async function buildNetworkContexts(entities, database) {
+    const networkIds = [...new Set(entities.map((e) => e.networkId))];
+    const networks = await Promise.all(networkIds.map((nid) => database.getNetwork(nid).then((n) => ({ nid, n }))));
+    const contexts = {};
+    for (const { nid, n: network } of networks) {
+        if (!network)
+            continue;
+        const perms = (network.permissions ?? {});
+        const injection = perms.contextInjection;
+        if (injection?.discovery === false)
+            continue;
+        contexts[nid] = renderNetworkContext({
+            type: network.type ?? 'community',
+            title: network.title,
+            prompt: network.prompt,
+            metadata: network.metadata ?? {},
+        });
+    }
+    return contexts;
+}
+/**
+ * Factory class to build and compile the Opportunity Graph.
+ * Uses dependency injection for testability.
+ */
+export class OpportunityGraphFactory {
+    constructor(database, embedder, hydeGenerator, optionalEvaluator, queueNotification, negotiationGraph, 
+    /**
+     * Used on the chat path to decide whether to wait for the user's personal
+     * agent (long timeout) or fall back to the system agent immediately
+     * (short timeout). Without it, the chat path always uses a short timeout.
+     */
+    agentDispatcher, 
+    /**
+     * Callback to enqueue a negotiate_existing job for an opportunity.
+     * When provided, negotiate_existing mode uses this to queue follow-up
+     * negotiations after introducer approval.
+     */
+    queueNegotiateExisting, 
+    /** Host-side P4b stamper. Omitted by manual/introducer/enrichment roots. */
+    stampNewbornOpportunities) {
+        this.database = database;
+        this.embedder = embedder;
+        this.hydeGenerator = hydeGenerator;
+        this.optionalEvaluator = optionalEvaluator;
+        this.queueNotification = queueNotification;
+        this.negotiationGraph = negotiationGraph;
+        this.agentDispatcher = agentDispatcher;
+        this.queueNegotiateExisting = queueNegotiateExisting;
+        this.stampNewbornOpportunities = stampNewbornOpportunities;
+    }
+    createGraph() {
+        const evaluatorAgent = this.optionalEvaluator ?? new OpportunityEvaluator();
+        // ═══════════════════════════════════════════════════════════════
+        // NODE DEFINITIONS
+        // ═══════════════════════════════════════════════════════════════
+        /**
+         * Wraps a graph node function to emit agent_start/agent_end trace events
+         * at its boundaries so the frontend TRACE panel shows real-time progress.
+         * @param traceName - Kebab-case agent name (e.g. "opportunity-prep")
+         * @param nodeFn - The original node function
+         * @param summaryFn - Optional function to derive a summary string from the node result
+         */
+        function withNodeTrace(traceName, nodeFn, summaryFn) {
+            return async (state) => {
+                const traceEmitter = requestContext.getStore()?.traceEmitter;
+                const nodeStart = Date.now();
+                traceEmitter?.({ type: "agent_start", name: traceName });
+                try {
+                    const result = await nodeFn(state);
+                    const durationMs = Date.now() - nodeStart;
+                    const summary = summaryFn?.(result) ?? undefined;
+                    traceEmitter?.({ type: "agent_end", name: traceName, durationMs, summary });
+                    return result;
+                }
+                catch (err) {
+                    const durationMs = Date.now() - nodeStart;
+                    const errMsg = err instanceof Error ? err.message : String(err);
+                    traceEmitter?.({ type: "agent_end", name: traceName, durationMs, summary: `error: ${errMsg}` });
+                    throw err;
+                }
+            };
+        }
+        /**
+         * Node 0: Prep
+         * Fetches user's network memberships and validates requirements.
+         * Returns empty if user has no network memberships (requirement).
+         */
+        const prepNode = withNodeTrace("opportunity-prep", async (state) => timed("OpportunityGraph.prep", async () => withCallLogging(prepLog, 'prepNode', {
+            userId: state.userId,
+            hasSearchQuery: !!state.searchQuery,
+            requestedIndexId: state.networkId ?? undefined,
+        }, async () => {
+            // Use getNetworkMemberships (all memberships) for search scope — NOT getUserIndexIds
+            // (which filters by autoAssign=true and is intended only for intent assignment).
+            const memberships = await this.database.getNetworkMemberships(state.userId);
+            const userNetworkIds = memberships.map(m => m.networkId);
+            if (userNetworkIds.length === 0) {
+                prepLog.verbose('User has no network memberships - cannot find opportunities');
+                return {
+                    userNetworks: [],
+                    sourceProfile: null,
+                    error: 'You need to join at least one network to find opportunities.',
+                };
+            }
+            const discoveryUserId = state.onBehalfOfUserId ?? state.userId;
+            const [intents, profile] = await Promise.all([
+                this.database.getActiveIntents(discoveryUserId),
+                this.database.getProfile(discoveryUserId),
+            ]);
+            const indexedIntents = intents.map((intent) => ({
+                intentId: intent.id,
+                payload: intent.payload,
+                summary: intent.summary ?? undefined,
+                indexes: [],
+            }));
+            const sourceProfile = profile
+                ? {
+                    identity: profile.identity ?? undefined,
+                    context: profile.context ?? undefined,
+                }
+                : null;
+            // Source premises are loaded after scope is resolved so premise discovery
+            // only uses premises assigned to the target network(s), and only up to
+            // DISCOVERY_SOURCE_PREMISE_LIMIT. Loading all premises here caused
+            // BACKEND-5: thousands of parallel vector searches for premise-rich users.
+            const sourcePremises = [];
+            const contextToIntentEnabled = process.env.DISCOVERY_CONTEXT_TO_INTENT !== '0';
+            const rawContexts = contextToIntentEnabled && typeof this.database.getUserContexts === 'function'
+                ? await this.database.getUserContexts(discoveryUserId)
+                : [];
+            const sourceContexts = rawContexts
+                // The global row (networkId: null) is excluded here — it is not in
+                // userNetworkIds — so context-to-intent discovery stays network-scoped.
+                .filter((c) => c.embedding && c.embedding.length > 0 && c.networkId !== null && userNetworkIds.includes(c.networkId))
+                .map((c) => ({
+                contextId: c.id,
+                networkId: c.networkId,
+                text: c.text,
+                embedding: c.embedding,
+            }));
+            return {
+                userNetworks: userNetworkIds,
+                indexedIntents,
+                sourceProfile,
+                sourcePremises,
+                sourceContexts,
+                trace: [{
+                        node: "prep",
+                        detail: `${userNetworkIds.length} network(s), ${intents.length} intent(s), premise discovery deferred, ${sourceContexts.length} context(s), ${profile ? 'profile loaded' : 'no profile'}`,
+                    }],
+            };
+        }, { context: { userId: state.userId }, logOutput: true }).catch((error) => {
+            const errMsg = error instanceof Error ? error.message : String(error);
+            prepLog.error('Failed', { error });
+            return {
+                error: 'Failed to prepare opportunity search. Please try again.',
+                trace: [{
+                        node: "prep_fatal",
+                        detail: `Prep failed: ${errMsg}`,
+                        data: { error: errMsg },
+                    }],
+            };
+        })), (result) => {
+            const r = result;
+            if (r?.error)
+                return `error: ${r.error}`;
+            const indexes = r?.userNetworks;
+            const intents = r?.indexedIntents;
+            return indexes && intents ? `${indexes.length} index(es), ${intents.length} intent(s)` : undefined;
+        });
+        /**
+         * Node 1: Scope
+         * Determines which indexes to search within.
+         * If networkId provided: searches only that index.
+         * Otherwise: searches all user's indexes.
+         */
+        const scopeNode = withNodeTrace("opportunity-scope", async (state) => {
+            return timed("OpportunityGraph.scope", async () => {
+                scopeLog.verbose('Determining search scope', {
+                    requestedIndexId: state.networkId,
+                    userNetworksCount: state.userNetworks.length,
+                });
+                try {
+                    let targetIndexIds;
+                    if (state.networkId) {
+                        // Validate user is member or owner of requested network
+                        const isInScope = state.userNetworks.includes(state.networkId);
+                        const isOwner = !isInScope && await this.database.isIndexOwner(state.networkId, state.userId);
+                        if (!isInScope && !isOwner) {
+                            scopeLog.warn('User not member of requested network', {
+                                networkId: state.networkId,
+                            });
+                            return {
+                                targetNetworks: [],
+                                error: 'You are not a member of that network.',
+                            };
+                        }
+                        targetIndexIds = [state.networkId];
+                    }
+                    else if (state.indexScope !== undefined) {
+                        // Bounded scope (e.g. a network-scoped agent's reachable networks):
+                        // intersect with the user's actual memberships so discovery never
+                        // reaches networks outside the agent's bound scope. An explicit
+                        // empty scope is authoritative and must fail closed.
+                        const allowed = new Set(state.indexScope);
+                        targetIndexIds = state.userNetworks.filter((n) => allowed.has(n));
+                        scopeLog.verbose('Applied indexScope intersection', {
+                            indexScopeCount: state.indexScope.length,
+                            userNetworksCount: state.userNetworks.length,
+                            targetCount: targetIndexIds.length,
+                        });
+                    }
+                    else {
+                        // Search all user's indexes
+                        targetIndexIds = state.userNetworks;
+                    }
+                    if (state.triggerIntentId) {
+                        // A trigger intent is an authoritative discovery boundary, not just
+                        // ranking context. Recompute the intersection at the graph edge so
+                        // direct chat/MCP callers cannot bypass FromIntentQueue admission.
+                        const assignedNetworkIds = new Set(await this.database.getNetworkIdsForIntent(state.triggerIntentId));
+                        const activeOwnerNetworkIds = new Set(state.userNetworks);
+                        targetIndexIds = targetIndexIds.filter((networkId) => assignedNetworkIds.has(networkId) && activeOwnerNetworkIds.has(networkId));
+                        scopeLog.verbose('Applied trigger-intent network intersection', {
+                            triggerIntentId: state.triggerIntentId,
+                            assignedCount: assignedNetworkIds.size,
+                            targetCount: targetIndexIds.length,
+                        });
+                    }
+                    // Fetch index details
+                    const targetNetworks = await Promise.all(targetIndexIds.map(async (networkId) => {
+                        const index = await this.database.getNetwork(networkId);
+                        const memberCount = await this.database.getNetworkMemberCount(networkId);
+                        return {
+                            networkId,
+                            title: index?.title ?? 'Unknown',
+                            memberCount,
+                        };
+                    }));
+                    scopeLog.verbose('Scope determined', {
+                        targetIndexesCount: targetNetworks.length,
+                        indexes: targetNetworks.map(i => i.title),
+                    });
+                    // ── Populate index relevancy scores for dedup tie-breaking ──
+                    const indexRelevancyScores = {};
+                    if (state.triggerIntentId) {
+                        // Background path: look up persisted scores from intent_indexes
+                        try {
+                            const scores = await this.database.getIntentIndexScores(state.triggerIntentId);
+                            for (const { networkId, relevancyScore } of scores) {
+                                if (relevancyScore != null) {
+                                    indexRelevancyScores[networkId] = relevancyScore;
+                                }
+                            }
+                        }
+                        catch (err) {
+                            scopeLog.warn('Failed to load intent index scores', { triggerIntentId: state.triggerIntentId, error: err });
+                        }
+                    }
+                    else if (state.searchQuery?.trim()) {
+                        // Chat path: score query against target indexes in parallel
+                        try {
+                            const indexer = new IntentIndexer();
+                            const scopeAgentTimings = [];
+                            const scorableIndexes = targetNetworks.filter(ti => ti.title !== 'Unknown');
+                            const scoringPromises = scorableIndexes.map(async (ti) => {
+                                const ctx = await this.database.getNetworkMemberContext(ti.networkId, state.userId);
+                                if (!ctx?.indexPrompt?.trim() && !ctx?.memberPrompt?.trim()) {
+                                    return { networkId: ti.networkId, score: 1.0 };
+                                }
+                                const _indexerStart = Date.now();
+                                const traceEmitter = requestContext.getStore()?.traceEmitter;
+                                traceEmitter?.({ type: "agent_start", name: "intent-networker" });
+                                let result = null;
+                                try {
+                                    result = await indexer.invoke(state.searchQuery, ctx?.indexPrompt ?? null, ctx?.memberPrompt ?? null);
+                                }
+                                catch {
+                                    return { networkId: ti.networkId, score: 1.0 };
+                                }
+                                finally {
+                                    const _indexerDuration = Date.now() - _indexerStart;
+                                    traceEmitter?.({ type: "agent_end", name: "intent-networker", durationMs: _indexerDuration, summary: `Scored index ${ti.networkId}` });
+                                    scopeAgentTimings.push({ name: 'intent.indexer', durationMs: _indexerDuration });
+                                }
+                                if (!result)
+                                    return { networkId: ti.networkId, score: 1.0 };
+                                const score = ctx?.indexPrompt && ctx?.memberPrompt
+                                    ? result.indexScore * 0.6 + result.memberScore * 0.4
+                                    : ctx?.indexPrompt ? result.indexScore : result.memberScore;
+                                return { networkId: ti.networkId, score };
+                            });
+                            const results = await Promise.all(scoringPromises);
+                            for (const { networkId, score } of results) {
+                                indexRelevancyScores[networkId] = score;
+                            }
+                            // Accumulate indexer timings into graph state
+                            if (scopeAgentTimings.length > 0) {
+                                return {
+                                    targetNetworks,
+                                    indexRelevancyScores,
+                                    agentTimings: scopeAgentTimings,
+                                    trace: [{
+                                            node: "scope",
+                                            detail: `Searching ${targetNetworks.length} index(es): ${targetNetworks.map(i => `${i.title} (${i.memberCount})`).join(', ')}`,
+                                            data: { totalMembers: targetNetworks.reduce((sum, i) => sum + i.memberCount, 0) },
+                                        }],
+                                };
+                            }
+                        }
+                        catch (err) {
+                            scopeLog.warn('Failed to score query against indexes', { error: err });
+                        }
+                    }
+                    const totalMembers = targetNetworks.reduce((sum, i) => sum + i.memberCount, 0);
+                    return {
+                        targetNetworks,
+                        indexRelevancyScores,
+                        trace: [{
+                                node: "scope",
+                                detail: `Searching ${targetNetworks.length} index(es): ${targetNetworks.map(i => `${i.title} (${i.memberCount})`).join(', ')}`,
+                                data: { totalMembers },
+                            }],
+                    };
+                }
+                catch (error) {
+                    const errMsg = error instanceof Error ? error.message : String(error);
+                    scopeLog.error('Failed', { error });
+                    return {
+                        targetNetworks: [],
+                        error: 'Failed to determine search scope.',
+                        trace: [{
+                                node: "scope_fatal",
+                                detail: `Scope failed: ${errMsg}`,
+                                data: { error: errMsg },
+                            }],
+                    };
+                }
+            });
+        }, (result) => {
+            const r = result;
+            if (r?.error)
+                return `error: ${r.error}`;
+            const indexes = r?.targetNetworks;
+            return indexes ? `${indexes.length} index(es) in scope` : undefined;
+        });
+        /**
+         * Node 2: Resolve
+         * Resolves trigger intent from triggerIntentId or searchQuery vs indexedIntents;
+         * sets discoverySource, resolvedTriggerIntentId, resolvedIntentInIndex for routing (path A/B/C).
+         */
+        const resolveNode = withNodeTrace("opportunity-resolve", async (state) => {
+            return timed("OpportunityGraph.resolve", async () => {
+                resolveLog.verbose('Resolving intent and network membership', {
+                    triggerIntentId: state.triggerIntentId,
+                    hasSearchQuery: !!state.searchQuery,
+                    indexedIntentsCount: state.indexedIntents.length,
+                });
+                const targetIndexIds = state.targetNetworks.map((t) => t.networkId);
+                try {
+                    let resolvedIntentId;
+                    if (state.triggerIntentId) {
+                        const isOwnedActiveIntent = state.indexedIntents.some((intent) => intent.intentId === state.triggerIntentId);
+                        if (!isOwnedActiveIntent) {
+                            resolveLog.warn('Trigger intent is not an active intent owned by the discovery user', {
+                                triggerIntentId: state.triggerIntentId,
+                                userId: state.userId,
+                            });
+                            return {
+                                resolvedTriggerIntentId: undefined,
+                                resolvedIntentInIndex: false,
+                                discoverySource: 'context',
+                                error: 'Trigger intent is not available for discovery.',
+                            };
+                        }
+                        const inNetwork = await this.database.getNetworkIdsForIntent(state.triggerIntentId);
+                        const inTarget = inNetwork.some((id) => targetIndexIds.includes(id));
+                        resolvedIntentId = state.triggerIntentId;
+                        const resolvedIntentInIndex = inTarget;
+                        const discoverySource = resolvedIntentInIndex ? 'intent' : 'context';
+                        return {
+                            resolvedTriggerIntentId: resolvedIntentId,
+                            resolvedIntentInIndex,
+                            discoverySource,
+                        };
+                    }
+                    if (state.searchQuery?.trim() && state.indexedIntents.length > 0) {
+                        const q = state.searchQuery.trim().toLowerCase();
+                        const matched = state.indexedIntents.find((i) => i.payload?.toLowerCase().includes(q));
+                        if (matched) {
+                            resolvedIntentId = matched.intentId;
+                            const inNetwork = await this.database.getNetworkIdsForIntent(matched.intentId);
+                            const resolvedIntentInIndex = inNetwork.some((id) => targetIndexIds.includes(id));
+                            const discoverySource = resolvedIntentInIndex ? 'intent' : 'context';
+                            return {
+                                resolvedTriggerIntentId: resolvedIntentId,
+                                resolvedIntentInIndex,
+                                discoverySource,
+                            };
+                        }
+                        resolveLog.warn('No intent matched search query; leaving resolvedIntentId unset', {
+                            searchQuery: state.searchQuery,
+                            indexedIntentsCount: state.indexedIntents.length,
+                        });
+                    }
+                    return {
+                        resolvedTriggerIntentId: undefined,
+                        resolvedIntentInIndex: false,
+                        discoverySource: 'context',
+                    };
+                }
+                catch (err) {
+                    const errMsg = err instanceof Error ? err.message : String(err);
+                    resolveLog.error('Failed', {
+                        triggerIntentId: state.triggerIntentId,
+                        searchQuery: state.searchQuery,
+                        error: err,
+                    });
+                    return {
+                        resolvedTriggerIntentId: undefined,
+                        resolvedIntentInIndex: false,
+                        discoverySource: 'context',
+                        error: errMsg || 'Resolve failed',
+                        trace: [{
+                                node: "resolve_fatal",
+                                detail: `Resolve failed: ${errMsg}`,
+                                data: { error: errMsg },
+                            }],
+                    };
+                }
+            });
+        }, (result) => {
+            const r = result;
+            if (r?.error)
+                return `error: ${r.error}`;
+            return r?.discoverySource ? `source: ${r.discoverySource}` : undefined;
+        });
+        /**
+         * Node 3: Discovery
+         * Generates HyDE embeddings and performs semantic search.
+         */
+        const discoveryNode = withNodeTrace("opportunity-discovery", async (state) => {
+            const self = this;
+            return timed("OpportunityGraph.discovery", async () => {
+                const startTime = Date.now();
+                const discoveryUserId = state.onBehalfOfUserId ?? state.userId;
+                /** Filter candidates to targetUserId when set (direct-connection mode). */
+                const filterByTarget = (candidates) => {
+                    if (!state.targetUserId)
+                        return candidates;
+                    const filtered = candidates.filter(c => c.candidateUserId === state.targetUserId);
+                    discoveryLog.verbose('targetUserId filter applied', {
+                        targetUserId: state.targetUserId,
+                        before: candidates.length,
+                        after: filtered.length,
+                    });
+                    return filtered;
+                };
+                // Shared variable to capture lens input data from runQueryHydeDiscovery or intent path
+                let discoveryLensInput;
+                // Shared variable to capture HyDE output (lenses + documents) for trace entries
+                let discoveryHydeOutput;
+                discoveryLog.verbose('Starting semantic search', {
+                    targetIndexesCount: state.targetNetworks.length,
+                    discoverySource: state.discoverySource,
+                    searchQueryPreview: state.searchQuery?.trim().slice(0, 60) ?? '(none)',
+                });
+                try {
+                    if (state.targetNetworks.length === 0) {
+                        discoveryLog.warn('No target indexes for search');
+                        return { candidates: [] };
+                    }
+                    // ── Direct-connection fast path ──
+                    // When targetUserId is set (user @-mentioned someone), bypass vector search
+                    // and construct candidates directly from shared networks.
+                    if (state.targetUserId) {
+                        if (state.targetUserId === discoveryUserId) {
+                            discoveryLog.warn('Direct-connection target matches discoverer; skipping self-match', {
+                                targetUserId: state.targetUserId,
+                            });
+                            return {
+                                candidates: [],
+                                trace: [{
+                                        node: "discovery",
+                                        detail: "Direct connection skipped: target user is discoverer",
+                                        data: { targetUserId: state.targetUserId },
+                                    }],
+                            };
+                        }
+                        discoveryLog.verbose('Direct-connection mode — bypassing vector search', {
+                            targetUserId: state.targetUserId,
+                        });
+                        const targetMemberships = await this.database.getNetworkMemberships(state.targetUserId);
+                        const targetUserIndexIds = targetMemberships.map(m => m.networkId);
+                        const sharedIndexIds = state.targetNetworks
+                            .filter(ti => targetUserIndexIds.includes(ti.networkId))
+                            .map(ti => ti.networkId);
+                        if (sharedIndexIds.length === 0) {
+                            discoveryLog.warn('Target user shares no indexes with discoverer', {
+                                targetUserId: state.targetUserId,
+                                discovererIndexes: state.targetNetworks.map(ti => ti.networkId),
+                            });
+                            return {
+                                candidates: [],
+                                trace: [{
+                                        node: "discovery",
+                                        detail: `Direct connection: target user shares no indexes`,
+                                        data: { targetUserId: state.targetUserId },
+                                    }],
+                            };
+                        }
+                        // Fetch target user's active intents to build intent-level candidates
+                        const targetIntents = await this.database.getActiveIntents(state.targetUserId);
+                        const directCandidates = [];
+                        if (targetIntents.length > 0) {
+                            // Build one candidate per intent per shared network it belongs to
+                            for (const intent of targetIntents) {
+                                const intentNetworkIds = await this.database.getNetworkIdsForIntent(intent.id);
+                                const overlapping = sharedIndexIds.filter(id => intentNetworkIds.includes(id));
+                                for (const networkId of overlapping) {
+                                    directCandidates.push(withCandidateEvidence({
+                                        candidateUserId: state.targetUserId,
+                                        candidateIntentId: intent.id,
+                                        networkId,
+                                        similarity: 1.0,
+                                        lens: 'explicit_mention',
+                                        candidatePayload: intent.payload,
+                                        candidateSummary: intent.summary ?? undefined,
+                                        discoverySource: 'query',
+                                    }));
+                                }
+                            }
+                        }
+                        // Always add a profile-level candidate (so evaluation runs even without intents)
+                        if (directCandidates.length === 0) {
+                            directCandidates.push(withCandidateEvidence({
+                                candidateUserId: state.targetUserId,
+                                networkId: sharedIndexIds[0],
+                                similarity: 1.0,
+                                lens: 'explicit_mention',
+                                candidatePayload: '',
+                                candidateSummary: undefined,
+                                discoverySource: 'query',
+                            }));
+                        }
+                        discoveryLog.verbose('Direct candidates constructed', {
+                            count: directCandidates.length,
+                            sharedIndexes: sharedIndexIds.length,
+                            targetIntents: targetIntents.length,
+                        });
+                        return {
+                            candidates: directCandidates,
+                            trace: [{
+                                    node: "discovery",
+                                    detail: `Direct connection → ${directCandidates.length} candidate(s) from ${sharedIndexIds.length} shared network(es)`,
+                                    data: {
+                                        targetUserId: state.targetUserId,
+                                        candidateCount: directCandidates.length,
+                                        sharedIndexes: sharedIndexIds.length,
+                                        durationMs: Date.now() - startTime,
+                                    },
+                                }],
+                        };
+                    }
+                    // Search limits - fixed values for candidate retrieval
+                    // (The options.limit controls final output, not search pool)
+                    const limitPerStrategy = 30;
+                    const perIndexLimit = 80;
+                    // Similarity threshold for recall (0.30 = 30% similarity)
+                    const minScore = 0.3;
+                    if (state.discoverySource === 'context') {
+                        // Context discovery: HyDE (when search query exists) + premise-to-premise.
+                        if (state.searchQuery?.trim()) {
+                            discoveryLog.verbose('Context source with searchQuery → running query HyDE + premise paths', {
+                                searchQuery: state.searchQuery.trim().substring(0, 80),
+                            });
+                            const queryCandidates = await runQueryHydeDiscovery();
+                            discoveryLog.verbose('Query HyDE path complete', { candidatesFound: queryCandidates.length });
+                            // Build trace entries for this path
+                            const traceEntries = [];
+                            // Lens input trace (captured from runQueryHydeDiscovery)
+                            if (discoveryLensInput) {
+                                traceEntries.push({
+                                    node: "lens_input",
+                                    detail: "Profile context for lens inference",
+                                    data: discoveryLensInput,
+                                });
+                            }
+                            // Lens output and HyDE document traces (captured from runQueryHydeDiscovery)
+                            if (discoveryHydeOutput) {
+                                if (discoveryHydeOutput.lenses.length > 0) {
+                                    traceEntries.push({
+                                        node: "lens_output",
+                                        detail: `Inferred ${discoveryHydeOutput.lenses.length} lens(es): ${discoveryHydeOutput.lenses.map(l => l.label).join(', ')}`,
+                                        data: { lenses: discoveryHydeOutput.lenses, model: getModelName("lensInferrer") },
+                                    });
+                                }
+                                for (const [lens, doc] of Object.entries(discoveryHydeOutput.hydeDocuments)) {
+                                    if (doc?.hydeText) {
+                                        traceEntries.push({
+                                            node: "hyde_query",
+                                            detail: `[${lens}] "${doc.hydeText.slice(0, 120)}${doc.hydeText.length > 120 ? '...' : ''}"`,
+                                            data: { lens, hydeTextPreview: doc.hydeText.slice(0, 300) + (doc.hydeText.length > 300 ? '...' : '') },
+                                        });
+                                    }
+                                }
+                            }
+                            // Compute per-lens stats from deduped candidates
+                            const lensStats = {};
+                            for (const c of queryCandidates) {
+                                const s = c.lens || 'unknown';
+                                if (!lensStats[s])
+                                    lensStats[s] = { count: 0, avgSimilarity: 0 };
+                                lensStats[s].count++;
+                                lensStats[s].avgSimilarity += c.similarity;
+                            }
+                            for (const s of Object.values(lensStats)) {
+                                s.avgSimilarity = s.count > 0 ? Math.round((s.avgSimilarity / s.count) * 1000) / 1000 : 0;
+                            }
+                            traceEntries.push({
+                                node: "discovery",
+                                detail: `HyDE search → ${queryCandidates.length} candidate(s) from query path`,
+                                data: {
+                                    candidateCount: queryCandidates.length,
+                                    byLens: lensStats,
+                                    searchQuery: state.searchQuery?.trim().slice(0, 80),
+                                    durationMs: Date.now() - startTime,
+                                    model: getModelName("hydeGenerator"),
+                                },
+                            });
+                            const [premiseCands, contextCands] = await Promise.all([
+                                runPremiseDiscovery(),
+                                runContextToIntentDiscovery(),
+                            ]);
+                            const withPremisesAndContext = mergeStrategyCandidates(queryCandidates, premiseCands, contextCands);
+                            if (premiseCands.length > 0) {
+                                traceEntries.push({ node: "strategy", detail: `premise-to-premise → ${premiseCands.length} candidate(s)` });
+                            }
+                            if (contextCands.length > 0) {
+                                traceEntries.push({ node: "strategy", detail: `context-to-intent → ${contextCands.length} candidate(s)` });
+                            }
+                            return { candidates: filterByTarget(withPremisesAndContext), trace: traceEntries };
+                        }
+                        // No search query — premise-to-premise + context-to-intent discovery
+                        const [premiseCands, contextCands] = await Promise.all([
+                            runPremiseDiscovery(),
+                            runContextToIntentDiscovery(),
+                        ]);
+                        if (premiseCands.length > 0 || contextCands.length > 0) {
+                            const merged = mergeStrategyCandidates(premiseCands, contextCands);
+                            const traceEntries = [];
+                            if (premiseCands.length > 0) {
+                                traceEntries.push({ node: "strategy", detail: `premise-to-premise → ${premiseCands.length} candidate(s)` });
+                            }
+                            if (contextCands.length > 0) {
+                                traceEntries.push({ node: "strategy", detail: `context-to-intent → ${contextCands.length} candidate(s)` });
+                            }
+                            traceEntries.push({
+                                node: "discovery",
+                                detail: `${[premiseCands.length > 0 && 'premise-to-premise', contextCands.length > 0 && 'context-to-intent'].filter(Boolean).length} strategies → ${premiseCands.length + contextCands.length} raw, ${merged.length} after dedup`,
+                            });
+                            return { candidates: filterByTarget(merged), trace: traceEntries };
+                        }
+                        return { candidates: [] };
+                    }
+                    async function runQueryHydeDiscovery() {
+                        const searchText = state.searchQuery?.trim() ?? '';
+                        if (!searchText)
+                            return [];
+                        discoveryLog.verbose('runQueryHydeDiscovery start', { searchText: searchText.slice(0, 80) });
+                        const discovererContext = buildDiscovererContext(state.sourceProfile, state.indexedIntents);
+                        discoveryLensInput = {
+                            profileContext: discovererContext,
+                            model: getModelName("lensInferrer"),
+                        };
+                        const hydeResult = await self.hydeGenerator.invoke({
+                            sourceType: 'query',
+                            sourceText: searchText,
+                            forceRegenerate: false,
+                            profileContext: discovererContext,
+                        });
+                        const hydeEmbeddings = hydeResult.hydeEmbeddings;
+                        const lenses = hydeResult.lenses ?? [];
+                        discoveryHydeOutput = {
+                            lenses: lenses,
+                            hydeDocuments: (hydeResult.hydeDocuments ?? {}),
+                        };
+                        const embeddingKeys = hydeEmbeddings ? Object.keys(hydeEmbeddings) : [];
+                        discoveryLog.verbose('HyDE generator result', {
+                            lensCount: embeddingKeys.length,
+                            lenses: embeddingKeys,
+                        });
+                        if (!hydeEmbeddings || Object.keys(hydeEmbeddings).length === 0)
+                            return [];
+                        const lensMap = new Map(lenses.map(l => [l.label, l]));
+                        const lensEmbeddings = [];
+                        for (const [label, emb] of Object.entries(hydeEmbeddings)) {
+                            if (emb?.length) {
+                                const lens = lensMap.get(label);
+                                lensEmbeddings.push({ lens: label, corpus: lens?.corpus ?? 'profiles', embedding: emb });
+                            }
+                        }
+                        const all = [];
+                        await Promise.all(state.targetNetworks.map(async (targetIndex) => {
+                            const results = await self.embedder.searchWithHydeEmbeddings(lensEmbeddings, {
+                                indexScope: [targetIndex.networkId],
+                                excludeUserId: discoveryUserId,
+                                limitPerStrategy,
+                                limit: perIndexLimit,
+                                minScore,
+                            });
+                            for (const r of results.filter((x) => x.type === 'intent')) {
+                                all.push(withCandidateEvidence({
+                                    candidateUserId: r.userId,
+                                    candidateIntentId: r.id,
+                                    networkId: targetIndex.networkId,
+                                    similarity: r.score,
+                                    lens: r.matchedVia,
+                                    candidatePayload: '',
+                                    candidateSummary: undefined,
+                                    discoverySource: 'query',
+                                }));
+                            }
+                            for (const r of results.filter((x) => x.type === 'premise')) {
+                                all.push(withCandidateEvidence({
+                                    candidateUserId: r.userId,
+                                    candidatePremiseId: r.id,
+                                    networkId: targetIndex.networkId,
+                                    similarity: r.score,
+                                    lens: r.matchedVia,
+                                    candidatePayload: '',
+                                    candidateSummary: undefined,
+                                    discoverySource: 'query',
+                                }));
+                            }
+                        }));
+                        const intentCount = all.filter((c) => c.candidateIntentId).length;
+                        const premiseCount = all.filter((c) => c.candidatePremiseId).length;
+                        discoveryLog.verbose('searchWithHydeEmbeddings raw results', {
+                            total: all.length,
+                            fromIntent: intentCount,
+                            fromPremise: premiseCount,
+                        });
+                        const byKey = new Map();
+                        for (const c of all) {
+                            // Dedup by candidateUserId + entity (intent or premise), NOT by indexId.
+                            // Including indexId caused the same user to appear once per index they belong to.
+                            const entityKey = c.candidateIntentId ? `intent:${c.candidateIntentId}` : `premise:${c.candidatePremiseId}`;
+                            const key = `${c.candidateUserId}:${entityKey}`;
+                            if (!byKey.has(key) || c.similarity > (byKey.get(key)?.similarity ?? 0)) {
+                                byKey.set(key, c);
+                            }
+                        }
+                        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() {
+                        const targetNetworkIds = state.targetNetworks.map(t => t.networkId);
+                        if (targetNetworkIds.length === 0)
+                            return [];
+                        const sourceLimit = getSourcePremiseDiscoveryLimit();
+                        if (sourceLimit === 0) {
+                            discoveryLog.verbose('runPremiseDiscovery disabled by DISCOVERY_SOURCE_PREMISE_LIMIT=0');
+                            return [];
+                        }
+                        const sourcePremisesFromDb = self.database.getPremisesForUserInNetworks
+                            ? await self.database.getPremisesForUserInNetworks(discoveryUserId, targetNetworkIds, 'ACTIVE', sourceLimit)
+                            : await self.database.getPremisesForUser(discoveryUserId, 'ACTIVE');
+                        const sourcePremises = (sourcePremisesFromDb.length > 0
+                            ? sourcePremisesFromDb
+                                .filter(p => Array.isArray(p.embedding) && p.embedding.length > 0)
+                                .slice(0, sourceLimit)
+                                .map(p => ({ premiseId: p.id, embedding: p.embedding }))
+                            : (state.sourcePremises ?? []).slice(0, sourceLimit));
+                        if (sourcePremises.length === 0)
+                            return [];
+                        discoveryLog.verbose('runPremiseDiscovery start', {
+                            premiseCount: sourcePremises.length,
+                            sourceLimit,
+                            targetNetworks: targetNetworkIds.length,
+                            batched: !!self.database.searchPremisesBySimilarityBatch,
+                        });
+                        const rawResults = self.database.searchPremisesBySimilarityBatch
+                            ? await self.database.searchPremisesBySimilarityBatch({
+                                sources: sourcePremises,
+                                networkIds: targetNetworkIds,
+                                excludeUserId: discoveryUserId,
+                                limitPerSource: PREMISE_MATCH_LIMIT_PER_SOURCE,
+                            })
+                            : (await Promise.all(sourcePremises.map(async (sp) => {
+                                const results = await self.database.searchPremisesBySimilarity({
+                                    embedding: sp.embedding,
+                                    networkIds: targetNetworkIds,
+                                    excludeUserId: discoveryUserId,
+                                    limit: PREMISE_MATCH_LIMIT_PER_SOURCE,
+                                });
+                                return results.map((r) => ({ ...r, sourcePremiseId: sp.premiseId }));
+                            }))).flat();
+                        const premiseCandidates = [];
+                        for (const r of rawResults) {
+                            premiseCandidates.push(withCandidateEvidence({
+                                candidateUserId: r.userId,
+                                sourcePremiseId: r.sourcePremiseId,
+                                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());
+                        discoveryLog.verbose('runPremiseDiscovery complete', {
+                            sourcePremiseCount: sourcePremises.length,
+                            rawCount: premiseCandidates.length,
+                            dedupedCount: deduped.length,
+                        });
+                        return deduped;
+                    }
+                    /**
+                     * Context-to-intent discovery: searches intents using context HyDE embeddings.
+                     * When HyDE documents exist for a context, uses optimised hypothetical-document
+                     * embeddings via searchWithHydeEmbeddings. Falls back to raw context embedding
+                     * via searchIntentsByContextEmbedding when no HyDE docs are available.
+                     */
+                    async function runContextToIntentDiscovery() {
+                        if (!state.sourceContexts?.length)
+                            return [];
+                        const contextToIntentEnabled = process.env.DISCOVERY_CONTEXT_TO_INTENT !== '0';
+                        if (!contextToIntentEnabled)
+                            return [];
+                        const targetNetworkIds = state.targetNetworks.map(t => t.networkId);
+                        if (targetNetworkIds.length === 0)
+                            return [];
+                        discoveryLog.verbose('runContextToIntentDiscovery start', {
+                            contextCount: state.sourceContexts.length,
+                            targetNetworks: targetNetworkIds.length,
+                        });
+                        const contextCandidates = [];
+                        for (const ctx of state.sourceContexts.filter(c => targetNetworkIds.includes(c.networkId))) {
+                            // Attempt HyDE-enhanced search first
+                            const persistedHydeDocs = await self.database.getHydeDocumentsForSource('context', ctx.contextId);
+                            const hydeDocs = selectHydeDocumentsForGeneration(persistedHydeDocs, getHydeGenerationMode(), ctx.text);
+                            const lensEmbeddings = hydeDocs
+                                .filter(d => d.hydeEmbedding?.length > 0)
+                                .map(d => ({
+                                lens: d.strategy,
+                                corpus: (d.targetCorpus === 'intents' ? 'intents' : d.targetCorpus === 'premises' ? 'premises' : 'intents'),
+                                embedding: d.hydeEmbedding,
+                            }));
+                            if (lensEmbeddings.length > 0) {
+                                // HyDE-enhanced search: same path as query HyDE, scoped to this context's network
+                                const results = await self.embedder.searchWithHydeEmbeddings(lensEmbeddings, {
+                                    indexScope: [ctx.networkId],
+                                    excludeUserId: discoveryUserId,
+                                    limitPerStrategy: limitPerStrategy,
+                                    limit: 20,
+                                    minScore,
+                                });
+                                for (const r of results.filter(r => r.type === 'intent')) {
+                                    contextCandidates.push(withCandidateEvidence({
+                                        candidateUserId: r.userId,
+                                        candidateIntentId: r.id,
+                                        sourceContextId: ctx.contextId,
+                                        networkId: ctx.networkId,
+                                        similarity: r.score,
+                                        lens: r.matchedVia,
+                                        candidatePayload: '',
+                                        candidateSummary: undefined,
+                                        discoverySource: 'context-to-intent',
+                                    }));
+                                }
+                            }
+                            else {
+                                // Fallback: raw context embedding search (no HyDE docs yet)
+                                const results = await self.database.searchIntentsByContextEmbedding({
+                                    embedding: ctx.embedding,
+                                    networkIds: [ctx.networkId],
+                                    excludeUserId: discoveryUserId,
+                                    limit: 20,
+                                    minScore: minScore,
+                                });
+                                for (const r of results) {
+                                    contextCandidates.push(withCandidateEvidence({
+                                        candidateUserId: r.userId,
+                                        candidateIntentId: r.intentId,
+                                        sourceContextId: ctx.contextId,
+                                        networkId: r.networkId,
+                                        similarity: typeof r.similarity === 'number' ? r.similarity : parseFloat(String(r.similarity)),
+                                        lens: 'context_match',
+                                        candidatePayload: r.payload ?? '',
+                                        candidateSummary: r.summary ?? undefined,
+                                        discoverySource: 'context-to-intent',
+                                    }));
+                                }
+                            }
+                        }
+                        const byKey = new Map();
+                        for (const c of contextCandidates) {
+                            const key = `${c.candidateUserId}:${c.candidateIntentId ?? 'none'}:${c.networkId}`;
+                            if (!byKey.has(key) || c.similarity > (byKey.get(key)?.similarity ?? 0)) {
+                                byKey.set(key, c);
+                            }
+                        }
+                        const deduped = Array.from(byKey.values());
+                        discoveryLog.verbose('runContextToIntentDiscovery complete', {
+                            rawCount: contextCandidates.length,
+                            dedupedCount: deduped.length,
+                        });
+                        return deduped;
+                    }
+                    /**
+                     * Merge candidates from multiple strategies. Deduplicates by userId + networkId + entityId,
+                     * keeps the highest similarity, tracks which strategies found each candidate,
+                     * and applies a multi-strategy boost (+0.05 per additional strategy, boost capped at 0.15,
+                     * final similarity capped at 1.0).
+                     */
+                    function mergeStrategyCandidates(...groups) {
+                        const merged = new Map();
+                        for (const group of groups) {
+                            for (const c of group) {
+                                const entityId = c.candidateIntentId ?? c.candidatePremiseId ?? 'none';
+                                const key = `${c.candidateUserId}:${c.networkId}:${entityId}`;
+                                const existing = merged.get(key);
+                                if (!existing) {
+                                    merged.set(key, { ...c, _strategies: new Set([c.discoverySource ?? 'unknown']) });
+                                }
+                                else {
+                                    existing._strategies.add(c.discoverySource ?? 'unknown');
+                                    const mergedEvidence = mergeOpportunityEvidence(existing.evidence, c.evidence);
+                                    if (c.similarity > existing.similarity) {
+                                        Object.assign(existing, { ...c, evidence: mergedEvidence });
+                                    }
+                                    else {
+                                        existing.evidence = mergedEvidence;
+                                    }
+                                }
+                            }
+                        }
+                        return Array.from(merged.values()).map(({ _strategies, ...c }) => {
+                            const matchedStrategies = Array.from(_strategies);
+                            const boost = Math.min((_strategies.size - 1) * 0.05, 0.15);
+                            return {
+                                ...c,
+                                similarity: Math.min(c.similarity + boost, 1.0),
+                                matchedStrategies,
+                                evidence: withMatchedStrategies(mergeOpportunityEvidence(c.evidence), matchedStrategies),
+                            };
+                        });
+                    }
+                    const resolvedIntent = state.resolvedTriggerIntentId
+                        ? state.indexedIntents.find((i) => i.intentId === state.resolvedTriggerIntentId)
+                        : state.indexedIntents[0];
+                    const searchText = state.searchQuery ?? resolvedIntent?.payload ?? '';
+                    if (!searchText) {
+                        discoveryLog.warn('No search text available for intent path');
+                        const [premiseCands, contextCands] = await Promise.all([
+                            runPremiseDiscovery(),
+                            runContextToIntentDiscovery(),
+                        ]);
+                        const merged = mergeStrategyCandidates(premiseCands, contextCands);
+                        if (merged.length > 0) {
+                            return {
+                                candidates: filterByTarget(merged),
+                                trace: [{ node: "discovery", detail: `No search text; premise → ${premiseCands.length}, context → ${contextCands.length}, merged → ${merged.length} candidate(s)` }],
+                            };
+                        }
+                        return { candidates: [] };
+                    }
+                    const discovererContext = buildDiscovererContext(state.sourceProfile, state.indexedIntents);
+                    discoveryLensInput = {
+                        profileContext: discovererContext,
+                        model: getModelName("lensInferrer"),
+                    };
+                    const hydeResult = await this.hydeGenerator.invoke({
+                        sourceType: 'query',
+                        sourceText: searchText,
+                        forceRegenerate: false,
+                        profileContext: discovererContext,
+                    });
+                    const hydeEmbeddings = hydeResult.hydeEmbeddings;
+                    const lenses = hydeResult.lenses ?? [];
+                    if (!hydeEmbeddings || Object.keys(hydeEmbeddings).length === 0) {
+                        const [premiseCands, contextCands] = await Promise.all([
+                            runPremiseDiscovery(),
+                            runContextToIntentDiscovery(),
+                        ]);
+                        const merged = mergeStrategyCandidates(premiseCands, contextCands);
+                        if (merged.length > 0) {
+                            return {
+                                hydeEmbeddings: {},
+                                candidates: filterByTarget(merged),
+                                trace: [{ node: "discovery", detail: `No HyDE embeddings; premise → ${premiseCands.length}, context → ${contextCands.length}, merged → ${merged.length} candidate(s)` }],
+                            };
+                        }
+                        return { hydeEmbeddings: {}, candidates: [] };
+                    }
+                    const lensMap = new Map(lenses.map(l => [l.label, l]));
+                    const lensEmbeddings = [];
+                    for (const [label, emb] of Object.entries(hydeEmbeddings)) {
+                        if (emb?.length) {
+                            const lens = lensMap.get(label);
+                            lensEmbeddings.push({ lens: label, corpus: lens?.corpus ?? 'profiles', embedding: emb });
+                        }
+                    }
+                    const allCandidates = [];
+                    await Promise.all(state.targetNetworks.map(async (targetIndex) => {
+                        const results = await this.embedder.searchWithHydeEmbeddings(lensEmbeddings, {
+                            indexScope: [targetIndex.networkId],
+                            excludeUserId: discoveryUserId,
+                            limitPerStrategy,
+                            limit: perIndexLimit,
+                            minScore,
+                        });
+                        for (const result of results.filter((r) => r.type === 'intent')) {
+                            allCandidates.push(withCandidateEvidence({
+                                candidateUserId: result.userId,
+                                candidateIntentId: result.id,
+                                networkId: targetIndex.networkId,
+                                similarity: result.score,
+                                lens: result.matchedVia,
+                                candidatePayload: '',
+                                candidateSummary: undefined,
+                                discoverySource: 'query',
+                            }));
+                        }
+                        for (const result of results.filter((r) => r.type === 'premise')) {
+                            allCandidates.push(withCandidateEvidence({
+                                candidateUserId: result.userId,
+                                candidatePremiseId: result.id,
+                                networkId: targetIndex.networkId,
+                                similarity: result.score,
+                                lens: result.matchedVia,
+                                candidatePayload: '',
+                                candidateSummary: undefined,
+                                discoverySource: 'query',
+                            }));
+                        }
+                    }));
+                    const byUserAndIndex = new Map();
+                    for (const c of allCandidates) {
+                        const entityKey = c.candidateIntentId ? `intent:${c.candidateIntentId}` : `premise:${c.candidatePremiseId}`;
+                        const key = `${c.candidateUserId}:${c.networkId}:${entityKey}`;
+                        if (!byUserAndIndex.has(key) || c.similarity > (byUserAndIndex.get(key)?.similarity ?? 0)) {
+                            byUserAndIndex.set(key, c);
+                        }
+                    }
+                    const candidates = Array.from(byUserAndIndex.values());
+                    discoveryLog.verbose('Intent-path discovery complete', { candidatesFound: candidates.length });
+                    const usedLenses = Object.keys(hydeEmbeddings);
+                    // Build trace with individual candidate similarity scores
+                    const traceEntries = [];
+                    // Lens input trace
+                    if (discoveryLensInput) {
+                        traceEntries.push({
+                            node: "lens_input",
+                            detail: "Profile context for lens inference",
+                            data: discoveryLensInput,
+                        });
+                    }
+                    // Lens output trace
+                    if (lenses.length > 0) {
+                        traceEntries.push({
+                            node: "lens_output",
+                            detail: `Inferred ${lenses.length} lens(es): ${lenses.map(l => l.label).join(', ')}`,
+                            data: { lenses, model: getModelName("lensInferrer") },
+                        });
+                    }
+                    // Compute per-lens stats from deduped candidates
+                    const lensStats = {};
+                    for (const c of candidates) {
+                        const s = c.lens || 'unknown';
+                        if (!lensStats[s])
+                            lensStats[s] = { count: 0, avgSimilarity: 0 };
+                        lensStats[s].count++;
+                        lensStats[s].avgSimilarity += c.similarity;
+                    }
+                    for (const s of Object.values(lensStats)) {
+                        s.avgSimilarity = s.count > 0 ? Math.round((s.avgSimilarity / s.count) * 1000) / 1000 : 0;
+                    }
+                    traceEntries.push({
+                        node: "discovery",
+                        detail: `Query: "${searchText.slice(0, 50)}${searchText.length > 50 ? '...' : ''}" → ${candidates.length} candidate(s)`,
+                        data: {
+                            query: searchText.slice(0, 100),
+                            lenses: usedLenses,
+                            candidateCount: candidates.length,
+                            byLens: lensStats,
+                            durationMs: Date.now() - startTime,
+                            model: getModelName("hydeGenerator"),
+                        },
+                    });
+                    // Show the HyDE-generated hypothetical documents used for search
+                    const hydeDocuments = hydeResult.hydeDocuments;
+                    if (hydeDocuments) {
+                        for (const [lens, doc] of Object.entries(hydeDocuments)) {
+                            if (doc?.hydeText) {
+                                traceEntries.push({
+                                    node: "hyde_query",
+                                    detail: `[${lens}] "${doc.hydeText.slice(0, 120)}${doc.hydeText.length > 120 ? '...' : ''}"`,
+                                    data: {
+                                        lens,
+                                        hydeTextPreview: doc.hydeText.slice(0, 160) + (doc.hydeText.length > 160 ? '...' : ''),
+                                    },
+                                });
+                            }
+                        }
+                    }
+                    // Add top candidates with similarity scores
+                    const sortedCandidates = [...candidates].sort((a, b) => b.similarity - a.similarity).slice(0, 10);
+                    for (const c of sortedCandidates) {
+                        traceEntries.push({
+                            node: "match",
+                            detail: `Similarity ${Math.round(c.similarity * 100)}% via ${c.lens}`,
+                            data: {
+                                userId: c.candidateUserId,
+                                similarity: Math.round(c.similarity * 100),
+                                lens: c.lens,
+                                hasIntent: !!c.candidateIntentId,
+                            },
+                        });
+                    }
+                    const [premiseCands, contextCands] = await Promise.all([
+                        runPremiseDiscovery(),
+                        runContextToIntentDiscovery(),
+                    ]);
+                    const allStrategies = mergeStrategyCandidates(candidates, premiseCands, contextCands);
+                    if (premiseCands.length > 0 || contextCands.length > 0) {
+                        traceEntries.push({
+                            node: "discovery",
+                            detail: `+ Premise → ${premiseCands.length}, Context → ${contextCands.length}, merged to ${allStrategies.length} candidate(s)`,
+                        });
+                    }
+                    return {
+                        hydeEmbeddings: hydeEmbeddings,
+                        candidates: filterByTarget(allStrategies),
+                        trace: traceEntries,
+                    };
+                }
+                catch (error) {
+                    const errMsg = error instanceof Error ? error.message : String(error);
+                    discoveryLog.error('Failed', { error });
+                    return {
+                        candidates: [],
+                        error: 'Failed to search for candidates.',
+                        trace: [{
+                                node: "discovery_fatal",
+                                detail: `Discovery failed: ${errMsg}`,
+                                data: { error: errMsg },
+                            }],
+                    };
+                }
+            });
+        }, (result) => {
+            const r = result;
+            if (r?.error)
+                return `error: ${r.error}`;
+            const candidates = r?.candidates;
+            return candidates ? `Found ${candidates.length} candidate(s)` : undefined;
+        });
+        /**
+         * Node 3: Evaluation (Entity bundle)
+         * Builds entity bundle from source + candidates, invokes entity-bundle evaluator, maps to EvaluatedOpportunity with networkId from entities.
+         */
+        const evaluationNode = async (state) => {
+            return timed("OpportunityGraph.evaluation", async () => {
+                const startTime = Date.now();
+                evaluationLog.verbose('Starting evaluation', {
+                    candidatesCount: state.candidates.length,
+                });
+                if (state.candidates.length === 0) {
+                    evaluationLog.verbose('No candidates to evaluate');
+                    return { evaluatedOpportunities: [], agentTimings: [] };
+                }
+                // Batch candidates to avoid timeout - evaluate top 25 per batch, store remaining
+                const EVAL_BATCH_SIZE = 25;
+                const sortedCandidates = [...state.candidates]
+                    .sort((a, b) => b.similarity - a.similarity);
+                // Dedup by userId — when same similarity, prefer index with highest relevancyScore
+                const bestByUser = new Map();
+                for (const c of sortedCandidates) {
+                    const existing = bestByUser.get(c.candidateUserId);
+                    if (!existing) {
+                        bestByUser.set(c.candidateUserId, c);
+                    }
+                    else if (c.similarity > existing.similarity) {
+                        bestByUser.set(c.candidateUserId, c);
+                    }
+                    else if (c.similarity === existing.similarity) {
+                        // Tie-break: prefer index with higher relevancy score
+                        const cScore = state.indexRelevancyScores[c.networkId] ?? 0;
+                        const existingScore = state.indexRelevancyScores[existing.networkId] ?? 0;
+                        if (cScore > existingScore) {
+                            bestByUser.set(c.candidateUserId, c);
+                        }
+                    }
+                }
+                const dedupedCandidates = Array.from(bestByUser.values());
+                // Re-sort by similarity descending (Map iteration order doesn't guarantee sort)
+                dedupedCandidates.sort((a, b) => b.similarity - a.similarity);
+                const discoveryUserId = state.onBehalfOfUserId ?? state.userId;
+                let eligibleCandidates;
+                try {
+                    const requestedPairs = dedupedCandidates.flatMap((candidate) => [
+                        { userId: discoveryUserId, networkId: candidate.networkId },
+                        { userId: candidate.candidateUserId, networkId: candidate.networkId },
+                    ]);
+                    const activePairs = await this.database.getActiveNetworkMembershipPairs(requestedPairs);
+                    const activePairKeys = new Set(activePairs.map((pair) => networkMembershipPairKey(pair.userId, pair.networkId)));
+                    eligibleCandidates = dedupedCandidates.filter((candidate) => activePairKeys.has(networkMembershipPairKey(discoveryUserId, candidate.networkId))
+                        && activePairKeys.has(networkMembershipPairKey(candidate.candidateUserId, candidate.networkId)));
+                }
+                catch (error) {
+                    evaluationLog.error('Active network membership recheck failed; skipping evaluation', { error });
+                    return {
+                        candidates: [],
+                        evaluatedOpportunities: [],
+                        remainingCandidates: [],
+                        error: 'Failed to validate candidate network memberships.',
+                        agentTimings: [],
+                    };
+                }
+                if (eligibleCandidates.length < dedupedCandidates.length) {
+                    evaluationLog.info('Removed candidates without active network pairs before evaluation', {
+                        before: dedupedCandidates.length,
+                        after: eligibleCandidates.length,
+                        removed: dedupedCandidates.length - eligibleCandidates.length,
+                    });
+                }
+                if (eligibleCandidates.length === 0) {
+                    return { candidates: [], evaluatedOpportunities: [], remainingCandidates: [], agentTimings: [] };
+                }
+                if (dedupedCandidates.length < sortedCandidates.length) {
+                    evaluationLog.info("Deduped candidates by userId", {
+                        before: sortedCandidates.length,
+                        after: dedupedCandidates.length,
+                        removed: sortedCandidates.length - dedupedCandidates.length,
+                    });
+                }
+                // ── IND-567: Rejection cool-down penalty ────────────────────────────────────────────────────────
+                // Candidates with a recently rejected or stalled opportunity receive a
+                // similarity penalty so they are ranked lower (and often pushed out of
+                // the evaluation batch). This prevents cross-query re-surfacing of
+                // false-positive matches that were already caught downstream.
+                // The persist-node dedup is still the hard gate; this is a soft guard
+                // that reduces evaluator cost and LLM false-positive rate.
+                const rejectionCooldownIds = new Set();
+                if (eligibleCandidates.length > 0
+                    && typeof this.database.getRecentlyRejectedOpportunityCounterparties === 'function') {
+                    try {
+                        const cooldownMs = getRejectionCooldownMs();
+                        const ids = await this.database.getRecentlyRejectedOpportunityCounterparties(discoveryUserId, eligibleCandidates.map((c) => c.candidateUserId), cooldownMs);
+                        for (const id of ids)
+                            rejectionCooldownIds.add(id);
+                        if (rejectionCooldownIds.size > 0) {
+                            evaluationLog.info('IND-567 rejection cool-down: applying similarity penalty', {
+                                affectedCount: rejectionCooldownIds.size,
+                                cooldownDays: Math.round(cooldownMs / (24 * 60 * 60 * 1000)),
+                                penalty: REJECTION_COOLDOWN_SIMILARITY_PENALTY,
+                            });
+                        }
+                    }
+                    catch (err) {
+                        evaluationLog.warn('IND-567 rejection cool-down: lookup failed, skipping penalty', {
+                            error: err instanceof Error ? err.message : String(err),
+                        });
+                    }
+                }
+                // Apply penalty and re-sort so penalised candidates fall to the back.
+                const eligibleCandidatesAfterCooldown = rejectionCooldownIds.size > 0
+                    ? eligibleCandidates
+                        .map((c) => rejectionCooldownIds.has(c.candidateUserId)
+                        ? { ...c, similarity: c.similarity * REJECTION_COOLDOWN_SIMILARITY_PENALTY }
+                        : c)
+                        .sort((a, b) => b.similarity - a.similarity)
+                    : eligibleCandidates;
+                const batchToEvaluate = eligibleCandidatesAfterCooldown.slice(0, EVAL_BATCH_SIZE);
+                const remaining = eligibleCandidatesAfterCooldown.slice(EVAL_BATCH_SIZE);
+                // Early termination: if search was query-driven and no query-sourced candidates remain,
+                // clear remaining to prevent pointless pagination through non-query leftovers
+                const isQueryDriven = !!state.searchQuery?.trim();
+                const queryRemaining = remaining.filter((c) => c.discoverySource === 'query' || c.discoverySource == null);
+                const effectiveRemaining = isQueryDriven && queryRemaining.length === 0 ? [] : remaining;
+                if (isQueryDriven && remaining.length > 0 && queryRemaining.length === 0) {
+                    evaluationLog.info("Early termination: no query-sourced candidates remain", {
+                        droppedCandidates: remaining.length,
+                    });
+                }
+                if (effectiveRemaining.length > 0) {
+                    evaluationLog.verbose('Batched candidates for evaluation', {
+                        evaluating: batchToEvaluate.length,
+                        remaining: effectiveRemaining.length,
+                        total: sortedCandidates.length,
+                    });
+                }
+                const agentTimingsAccum = [];
+                try {
+                    const sourceProfile = await this.database.getProfile(discoveryUserId);
+                    const sourceEntity = {
+                        userId: discoveryUserId,
+                        profile: {
+                            name: sourceProfile?.identity?.name,
+                            bio: sourceProfile?.identity?.bio,
+                            location: sourceProfile?.identity?.location,
+                            context: sourceProfile?.context,
+                        },
+                        intents: state.indexedIntents.slice(0, 5).map((i) => ({
+                            intentId: i.intentId,
+                            payload: i.payload,
+                            summary: i.summary,
+                        })),
+                        networkId: '', // Placeholder — overwritten per-pairing below
+                        evidenceKey: `${discoveryUserId}::source`,
+                        ragScore: undefined,
+                        matchedVia: undefined,
+                    };
+                    const candidateEntities = await Promise.all(batchToEvaluate.map(async (c) => {
+                        const profile = await this.database.getProfile(c.candidateUserId);
+                        let intentPayload = c.candidatePayload;
+                        let intentSummary = c.candidateSummary;
+                        if (c.candidateIntentId != null && (!intentPayload || intentPayload === '')) {
+                            const intent = await this.database.getIntent(c.candidateIntentId);
+                            if (intent) {
+                                intentPayload = intent.payload;
+                                intentSummary = intent.summary ?? undefined;
+                            }
+                        }
+                        const evidenceKey = buildEvaluatorEvidenceKey(c);
+                        return {
+                            userId: c.candidateUserId,
+                            profile: {
+                                name: profile?.identity?.name,
+                                bio: profile?.identity?.bio,
+                                location: profile?.identity?.location,
+                                context: profile?.context,
+                            },
+                            intents: c.candidateIntentId != null
+                                ? [{ intentId: c.candidateIntentId, payload: intentPayload ?? '', summary: intentSummary }]
+                                : undefined,
+                            networkId: c.networkId,
+                            evidenceKey,
+                            ragScore: c.similarity * 100,
+                            matchedVia: c.lens,
+                            evidence: c.evidence,
+                        };
+                    }));
+                    const userIdToIndexId = new Map();
+                    const evidenceByEntityKey = new Map();
+                    const entityKeysByUserId = new Map();
+                    for (const e of candidateEntities) {
+                        if (!userIdToIndexId.has(e.userId))
+                            userIdToIndexId.set(e.userId, e.networkId);
+                        if (e.evidenceKey) {
+                            evidenceByEntityKey.set(e.evidenceKey, mergeOpportunityEvidence(evidenceByEntityKey.get(e.evidenceKey), e.evidence));
+                            entityKeysByUserId.set(e.userId, [...(entityKeysByUserId.get(e.userId) ?? []), e.evidenceKey]);
+                        }
+                    }
+                    function evidenceForActor(actor) {
+                        if (actor.evidenceKey)
+                            return evidenceByEntityKey.get(actor.evidenceKey);
+                        const keys = entityKeysByUserId.get(actor.userId) ?? [];
+                        const intentKey = actor.intentId ? keys.find((key) => key.endsWith(`:${actor.intentId}`)) : undefined;
+                        if (intentKey)
+                            return evidenceByEntityKey.get(intentKey);
+                        // Avoid leaking unrelated resource evidence when the evaluator collapsed multiple
+                        // candidates for the same user into a profile-only actor.
+                        if (keys.length === 1)
+                            return evidenceByEntityKey.get(keys[0]);
+                        return undefined;
+                    }
+                    // Lower default threshold to 50 for better recall
+                    const minScore = state.options.minScore ?? 50;
+                    const evaluator = typeof evaluatorAgent.invokeEntityBundle === 'function'
+                        ? evaluatorAgent
+                        : new OpportunityEvaluator();
+                    const runParallel = process.env.RUN_OPPORTUNITY_EVAL_IN_PARALLEL === 'true';
+                    const networkContexts = await buildNetworkContexts([sourceEntity, ...candidateEntities], this.database);
+                    // Declare trace entries early so both parallel and serial paths can push error entries
+                    const traceEntries = [];
+                    const parallelErrors = [];
+                    let pairwiseOpportunities;
+                    if (runParallel) {
+                        // Experimental: one LLM call per candidate, all fired in parallel
+                        evaluationLog.verbose('Running parallel evaluation', { candidates: candidateEntities.length });
+                        const parallelResults = await Promise.all(candidateEntities.map((candidateEntity) => {
+                            const input = {
+                                discovererId: discoveryUserId,
+                                entities: [sourceEntity, candidateEntity],
+                                existingOpportunities: state.options.existingOpportunities,
+                                ...(state.searchQuery?.trim() ? { discoveryQuery: state.searchQuery.trim() } : {}),
+                                networkContexts,
+                            };
+                            const _evalStart = Date.now();
+                            const _traceEmitter = requestContext.getStore()?.traceEmitter;
+                            _traceEmitter?.({ type: "agent_start", name: "opportunity-evaluator" });
+                            const _candidateName = candidateEntity.profile?.name ?? "Unknown";
+                            return evaluator.invokeEntityBundle(input, { minScore, returnAll: true })
+                                .then((res) => {
+                                const _evalDuration = Date.now() - _evalStart;
+                                agentTimingsAccum.push({ name: 'opportunity.evaluator', durationMs: _evalDuration });
+                                const _topScore = res.length > 0 ? Math.max(...res.map(r => r.score)) : -1;
+                                const _summary = _topScore < 0 ? `${_candidateName}: no match` : `${_candidateName}: ${_topScore}`;
+                                _traceEmitter?.({ type: "agent_end", name: "opportunity-evaluator", durationMs: _evalDuration, summary: _summary });
+                                return res;
+                            })
+                                .catch((err) => {
+                                const _evalDuration = Date.now() - _evalStart;
+                                const _errMsg = err instanceof Error ? err.message : String(err);
+                                agentTimingsAccum.push({ name: 'opportunity.evaluator', durationMs: _evalDuration });
+                                _traceEmitter?.({ type: "agent_end", name: "opportunity-evaluator", durationMs: _evalDuration, summary: `${_candidateName}: error — ${_errMsg}` });
+                                evaluationLog.warn('Parallel eval failed for candidate', {
+                                    candidateUserId: candidateEntity.userId,
+                                    error: err,
+                                });
+                                parallelErrors.push({
+                                    candidateUserId: candidateEntity.userId,
+                                    candidateName: _candidateName,
+                                    error: _errMsg,
+                                    durationMs: _evalDuration,
+                                });
+                                return [];
+                            });
+                        }));
+                        // Each call is already pairwise (source + 1 candidate) — flatten directly
+                        pairwiseOpportunities = parallelResults.flat();
+                        // Record trace entries for candidates that failed during parallel evaluation
+                        if (parallelErrors.length > 0) {
+                            traceEntries.push({
+                                node: "evaluation_errors",
+                                detail: `${parallelErrors.length}/${candidateEntities.length} candidate evaluation(s) failed`,
+                                data: {
+                                    failedCount: parallelErrors.length,
+                                    totalCandidates: candidateEntities.length,
+                                    errors: parallelErrors.map(e => ({
+                                        candidateUserId: e.candidateUserId,
+                                        candidateName: e.candidateName,
+                                        error: e.error,
+                                        durationMs: e.durationMs,
+                                    })),
+                                },
+                            });
+                        }
+                    }
+                    else {
+                        // Default: single bundled LLM call with all candidates
+                        const entities = [sourceEntity, ...candidateEntities];
+                        const input = {
+                            discovererId: discoveryUserId,
+                            entities,
+                            existingOpportunities: state.options.existingOpportunities,
+                            ...(state.searchQuery?.trim() ? { discoveryQuery: state.searchQuery.trim() } : {}),
+                            networkContexts,
+                        };
+                        // Get ALL scored results for tracing (returnAll: true), filter for persistence later
+                        const _evalStart = Date.now();
+                        const _traceEmitterSerial = requestContext.getStore()?.traceEmitter;
+                        _traceEmitterSerial?.({ type: "agent_start", name: "opportunity-evaluator" });
+                        let opportunitiesWithActors;
+                        try {
+                            opportunitiesWithActors = await evaluator.invokeEntityBundle(input, { minScore, returnAll: true });
+                            const _evalDuration = Date.now() - _evalStart;
+                            agentTimingsAccum.push({ name: 'opportunity.evaluator', durationMs: _evalDuration });
+                            _traceEmitterSerial?.({ type: "agent_end", name: "opportunity-evaluator", durationMs: _evalDuration, summary: `Evaluated ${candidateEntities.length} candidate(s)` });
+                        }
+                        catch (serialErr) {
+                            const _evalDuration = Date.now() - _evalStart;
+                            const _errMsg = serialErr instanceof Error ? serialErr.message : String(serialErr);
+                            agentTimingsAccum.push({ name: 'opportunity.evaluator', durationMs: _evalDuration });
+                            _traceEmitterSerial?.({ type: "agent_end", name: "opportunity-evaluator", durationMs: _evalDuration, summary: `error — ${_errMsg}` });
+                            throw serialErr; // Re-throw for the outer catch to handle
+                        }
+                        // Split multi-actor evaluator results into pairwise (viewer + candidate).
+                        // Each persisted discovery opportunity should have exactly 2 actors.
+                        // When splitting, build per-candidate reasoning from entity data because
+                        // the shared reasoning typically describes only one candidate.
+                        pairwiseOpportunities = [];
+                        for (const op of opportunitiesWithActors) {
+                            const pairwiseSourceId = state.onBehalfOfUserId ?? state.userId;
+                            const nonViewerActors = op.actors.filter(a => a.userId !== pairwiseSourceId);
+                            if (nonViewerActors.length <= 1) {
+                                pairwiseOpportunities.push(op);
+                            }
+                            else {
+                                evaluationLog.warn('Splitting multi-actor opportunity; LLM returned bundled actors instead of one-per-candidate', {
+                                    actorCount: nonViewerActors.length,
+                                    userIds: nonViewerActors.map(a => a.userId),
+                                });
+                                const viewerActor = op.actors.find(a => a.userId === pairwiseSourceId);
+                                for (const candidate of nonViewerActors) {
+                                    const entity = candidateEntities.find(e => e.userId === candidate.userId);
+                                    const candidateName = entity?.profile?.name ?? '';
+                                    const reasoningLower = op.reasoning.toLowerCase();
+                                    const mentionsCandidate = candidateName !== '' &&
+                                        reasoningLower.includes(candidateName.toLowerCase());
+                                    const mentionsOtherCandidate = nonViewerActors
+                                        .filter((actor) => actor.userId !== candidate.userId)
+                                        .map((actor) => candidateEntities.find((e) => e.userId === actor.userId)?.profile?.name?.toLowerCase())
+                                        .some((name) => name != null && reasoningLower.includes(name));
+                                    let reasoning;
+                                    if (mentionsCandidate && !mentionsOtherCandidate) {
+                                        reasoning = op.reasoning;
+                                    }
+                                    else if (entity?.profile) {
+                                        const p = entity.profile;
+                                        const parts = [p.name, p.bio].filter(Boolean);
+                                        if (p.skills?.length)
+                                            parts.push(`Skills: ${p.skills.join(', ')}`);
+                                        if (p.interests?.length)
+                                            parts.push(`Interests: ${p.interests.join(', ')}`);
+                                        reasoning = parts.join('. ') || op.reasoning;
+                                    }
+                                    else {
+                                        reasoning = op.reasoning;
+                                    }
+                                    pairwiseOpportunities.push({
+                                        reasoning,
+                                        score: op.score,
+                                        actors: [
+                                            viewerActor ?? { userId: pairwiseSourceId, role: 'patient', intentId: null },
+                                            candidate,
+                                        ],
+                                    });
+                                }
+                            }
+                        }
+                    }
+                    const evaluatedOpportunities = pairwiseOpportunities.map((op) => ({
+                        reasoning: op.reasoning,
+                        score: op.score,
+                        evidence: mergeOpportunityEvidence(...op.actors.map(evidenceForActor)),
+                        actors: op.actors.map((a) => {
+                            const isSource = a.userId === discoveryUserId;
+                            if (isSource) {
+                                // Source actor inherits the counterpart's networkId (shared match context)
+                                const counterpart = op.actors.find((other) => other.userId !== a.userId);
+                                const counterpartIndexId = counterpart
+                                    ? userIdToIndexId.get(counterpart.userId) ?? candidateEntities.find((e) => e.userId === counterpart.userId)?.networkId
+                                    : undefined;
+                                return {
+                                    userId: a.userId,
+                                    role: a.role,
+                                    intentId: a.intentId,
+                                    networkId: counterpartIndexId ?? userIdToIndexId.get(a.userId) ?? '',
+                                };
+                            }
+                            return {
+                                userId: a.userId,
+                                role: a.role,
+                                intentId: a.intentId,
+                                networkId: userIdToIndexId.get(a.userId) ?? candidateEntities.find((e) => e.userId === a.userId)?.networkId,
+                            };
+                        }),
+                    }));
+                    const passed = evaluatedOpportunities.filter((o) => o.score >= minScore);
+                    evaluationLog.verbose('Evaluation complete', {
+                        evaluatedCount: evaluatedOpportunities.length,
+                        passed: passed.length,
+                    });
+                    // Build detailed trace entries for each evaluated candidate
+                    // Threshold filter trace: how many candidates in this batch were above/below similarity threshold
+                    const aboveThreshold = batchToEvaluate.filter(c => c.similarity >= 0.40).length;
+                    const belowThreshold = batchToEvaluate.length - aboveThreshold;
+                    traceEntries.push({
+                        node: "threshold_filter",
+                        detail: `${aboveThreshold} above 0.40, ${belowThreshold} below (batch of ${batchToEvaluate.length})`,
+                        data: {
+                            aboveThreshold,
+                            belowThreshold,
+                            minScore: 0.40,
+                            batchSize: batchToEvaluate.length,
+                        },
+                    });
+                    // Create a map of evaluated candidates by userId for quick lookup.
+                    // Use discoveryUserId (which accounts for onBehalfOfUserId in introducer flow)
+                    // rather than state.userId (which is the introducer, not present in pairwise actors).
+                    const evaluatedByUserId = new Map();
+                    for (const opp of evaluatedOpportunities) {
+                        const candidateActor = opp.actors.find(a => a.userId !== discoveryUserId);
+                        if (candidateActor) {
+                            evaluatedByUserId.set(candidateActor.userId, { score: opp.score, reasoning: opp.reasoning });
+                        }
+                    }
+                    // Summary entry
+                    traceEntries.push({
+                        node: "evaluation",
+                        detail: `Evaluated ${candidateEntities.length} candidate(s) → ${passed.length} passed (min score ${minScore})`,
+                        data: {
+                            inputCandidates: batchToEvaluate.length,
+                            returnedFromEvaluator: evaluatedOpportunities.length,
+                            passedCount: passed.length,
+                            minScore,
+                            remaining: effectiveRemaining.length,
+                            batchNumber: 1,
+                            durationMs: Date.now() - startTime,
+                            model: getModelName("opportunityEvaluator"),
+                        },
+                    });
+                    // Individual candidate entries - show ALL candidates that went to evaluator
+                    for (const entity of candidateEntities) {
+                        const candidateName = entity.profile?.name || entity.userId.slice(0, 8);
+                        const candidateBio = entity.profile?.bio;
+                        const evaluated = evaluatedByUserId.get(entity.userId);
+                        const score = evaluated?.score;
+                        const reasoning = evaluated?.reasoning;
+                        const didPass = score !== undefined && score >= minScore;
+                        const status = score !== undefined
+                            ? (didPass ? '✓ passed' : `✗ score ${score}`)
+                            : '✗ not scored';
+                        traceEntries.push({
+                            node: "candidate",
+                            detail: `${candidateName}: ${status}`,
+                            data: {
+                                userId: entity.userId,
+                                name: candidateName,
+                                bio: candidateBio,
+                                score: score,
+                                passed: didPass,
+                                reasoning: reasoning || 'No evaluation returned for this candidate',
+                                matchedVia: entity.matchedVia,
+                                ragScore: entity.ragScore,
+                                model: getModelName("opportunityEvaluator"),
+                                intents: entity.intents?.map((i) => ({
+                                    intentId: i.intentId,
+                                    summary: (i.summary || i.payload || '').slice(0, 100),
+                                })),
+                                profile: entity.profile ? {
+                                    name: entity.profile.name,
+                                    location: entity.profile.location,
+                                } : undefined,
+                            },
+                        });
+                    }
+                    // Only pass opportunities that passed the threshold to downstream nodes
+                    const passedOpportunities = evaluatedOpportunities.filter((o) => o.score >= minScore);
+                    return {
+                        candidates: eligibleCandidates,
+                        evaluatedOpportunities: passedOpportunities,
+                        remainingCandidates: effectiveRemaining,
+                        trace: traceEntries,
+                        agentTimings: agentTimingsAccum,
+                    };
+                }
+                catch (error) {
+                    const errMsg = error instanceof Error ? error.message : String(error);
+                    evaluationLog.error('Failed', { error });
+                    return {
+                        evaluatedOpportunities: [],
+                        error: 'Failed to evaluate candidates.',
+                        trace: [{
+                                node: "evaluation_fatal",
+                                detail: `Evaluation failed: ${errMsg}`,
+                                data: {
+                                    error: errMsg,
+                                    candidateCount: state.candidates?.length ?? 0,
+                                    durationMs: Date.now() - startTime,
+                                },
+                            }],
+                        agentTimings: agentTimingsAccum,
+                    };
+                }
+            });
+        };
+        /**
+         * Node 3b: Negotiate (post-persist)
+         * Runs bilateral negotiation per persisted opportunity, passing opportunityId so the
+         * negotiation graph's finalize node updates each opportunity's status:
+         *   accept → 'pending'  (sender notification follows the pending → notification path)
+         *   reject → 'rejected'
+         *   timeout/turn_cap → 'stalled'
+         * Status updates land in the DB; in-memory state.opportunities is not mutated.
+         */
+        const NEGOTIATE_TIMER_SENTINEL = Symbol('negotiate-timer-sentinel');
+        const negotiateNode = async (state) => {
+            if (!this.negotiationGraph)
+                return {};
+            if (!state.opportunities || state.opportunities.length === 0)
+                return {};
+            const traceEmitter = requestContext.getStore()?.traceEmitter;
+            const graphStart = Date.now();
+            const persistedById = new Map(state.opportunities.map((opportunity) => [opportunity.id, opportunity]));
+            const attemptBoundaryById = new Map(state.opportunities.map((opportunity) => [opportunity.id, opportunity.updatedAt]));
+            const compensateTasklessNegotiatingOpportunity = async (opportunityId) => {
+                const opportunity = persistedById.get(opportunityId);
+                const expectedUpdatedAt = attemptBoundaryById.get(opportunityId);
+                if (opportunity?.status !== 'negotiating' || !expectedUpdatedAt)
+                    return;
+                const fallbackStatus = opportunity.actors.some((actor) => actor.role === 'introducer')
+                    ? 'latent'
+                    : 'draft';
+                await this.database
+                    .compensateTasklessNegotiatingOpportunity(opportunityId, expectedUpdatedAt, fallbackStatus)
+                    .catch((error) => {
+                    negotiateLog.warn('Failed to compensate taskless negotiating opportunity', {
+                        opportunityId,
+                        expectedUpdatedAt,
+                        fallbackStatus,
+                        error,
+                    });
+                });
+            };
+            traceEmitter?.({ type: "graph_start", name: "Negotiation graph" });
+            try {
+                // Use the same discoveryUserId pattern as evaluationNode
+                const discoveryUserId = (state.onBehalfOfUserId ?? state.userId);
+                const includeOtherIntents = negotiationIncludesOtherIntents();
+                const sourceAccount = await this.database.getUser(discoveryUserId).catch(() => null);
+                const sourceIntentInputs = (state.indexedIntents ?? []).map((intent) => ({
+                    id: intent.intentId,
+                    summary: intent.summary ?? null,
+                    payload: intent.payload ?? null,
+                }));
+                const sourceHasExactIntent = sourceIntentInputs.some((intent) => intent.id === state.triggerIntentId);
+                const sourceFallbackIntent = state.triggerIntentId && !sourceHasExactIntent
+                    ? await this.database.getIntent(state.triggerIntentId).catch(() => null)
+                    : null;
+                const ownedSourceFallback = sourceFallbackIntent?.userId === discoveryUserId
+                    ? sourceFallbackIntent
+                    : null;
+                const sourceUser = {
+                    id: discoveryUserId,
+                    intents: buildPrioritizedNegotiationIntents(sourceIntentInputs, state.triggerIntentId, ownedSourceFallback, includeOtherIntents),
+                    profile: {
+                        name: state.sourceProfile?.identity?.name ?? sourceAccount?.name,
+                        bio: state.sourceProfile?.identity?.bio ?? sourceAccount?.intro ?? undefined,
+                        location: state.sourceProfile?.identity?.location ?? sourceAccount?.location ?? undefined,
+                    },
+                };
+                // Build candidates from persisted opportunities. Each opportunity carries its DB id
+                // so the negotiation graph's finalize node can update its status from the outcome.
+                negotiateLog.verbose('Building candidates from opportunities', {
+                    opportunityCount: state.opportunities.length,
+                    discoveryUserId,
+                });
+                const filteredBeforeInvocation = [];
+                const candidateEntries = state.opportunities
+                    .map(opp => {
+                    // Skip opportunities where any introducer exists but has not yet approved.
+                    const introducerActors = opp.actors
+                        .filter(a => a.role === 'introducer');
+                    if (introducerActors.length > 0 && !introducerActors.every(a => a.approved === true)) {
+                        negotiateLog.verbose('Skipping opportunity: introducer not approved', {
+                            opportunityId: opp.id,
+                            introducerCount: introducerActors.length,
+                            approvedCount: introducerActors.filter(a => a.approved === true).length,
+                        });
+                        filteredBeforeInvocation.push(opp.id);
+                        return null;
+                    }
+                    const opportunityActors = opp.actors;
+                    const sourceActor = opportunityActors.find(a => a.userId === discoveryUserId && a.role !== 'introducer');
+                    const candidateActor = opportunityActors.find(a => a.userId !== discoveryUserId && a.role !== 'introducer');
+                    if (!sourceActor || !candidateActor) {
+                        negotiateLog.verbose('Skipping opportunity: no candidateActor found', {
+                            opportunityId: opp.id,
+                            discoveryUserId,
+                            actors: opp.actors?.map(a => ({ userId: a.userId, role: a.role })) ?? [],
+                        });
+                        filteredBeforeInvocation.push(opp.id);
+                        return null;
+                    }
+                    return { opp, sourceActor, candidateActor };
+                })
+                    .filter((e) => e !== null);
+                await Promise.all(filteredBeforeInvocation.map(compensateTasklessNegotiatingOpportunity));
+                negotiateLog.verbose('Candidate filtering complete', {
+                    inputOpportunities: state.opportunities.length,
+                    outputCandidates: candidateEntries.length,
+                });
+                const candidates = await Promise.all(candidateEntries.map(async ({ opp, sourceActor, candidateActor }) => {
+                    const userId = candidateActor.userId;
+                    const sourceIntentId = resolveOpportunityActorIntent(sourceActor);
+                    const candidateIntentId = resolveOpportunityActorIntent(candidateActor);
+                    const sourceExactActive = sourceIntentId
+                        ? sourceIntentInputs.find((sourceIntent) => sourceIntent.id === sourceIntentId)
+                        : undefined;
+                    const [profile, user, activeIntents, intent, sourceIntent] = await Promise.all([
+                        this.database.getProfile(userId).catch(() => null),
+                        this.database.getUser(userId).catch(() => null),
+                        includeOtherIntents
+                            ? this.database.getActiveIntents(userId).catch(() => [])
+                            : Promise.resolve([]),
+                        candidateIntentId
+                            ? this.database.getIntent(candidateIntentId).catch(() => null)
+                            : null,
+                        sourceIntentId && !sourceExactActive
+                            ? this.database.getIntent(sourceIntentId).catch(() => null)
+                            : null,
+                    ]);
+                    const ownedFallbackIntent = intent?.userId === userId ? intent : null;
+                    const ownedSourceIntent = sourceIntent?.userId === discoveryUserId ? sourceIntent : null;
+                    const candidateIntents = buildPrioritizedNegotiationIntents(activeIntents, candidateIntentId, ownedFallbackIntent, includeOtherIntents);
+                    return {
+                        userId,
+                        ...(sourceIntentId ? { sourceIntentId } : {}),
+                        ...(candidateIntentId ? { candidateIntentId } : {}),
+                        sourceUser: {
+                            ...sourceUser,
+                            intents: buildPrioritizedNegotiationIntents(sourceIntentInputs, sourceIntentId, ownedSourceIntent, includeOtherIntents),
+                        },
+                        opportunityId: opp.id,
+                        opportunityStatus: opp.status,
+                        opportunityUpdatedAt: opp.updatedAt,
+                        reasoning: opp.interpretation?.reasoning ?? '',
+                        valencyRole: candidateActor.role ?? 'peer',
+                        networkId: candidateActor.networkId,
+                        ...(state.searchQuery?.trim() && { discoveryQuery: state.searchQuery.trim() }),
+                        candidateUser: {
+                            id: userId,
+                            intents: candidateIntents,
+                            profile: {
+                                name: profile?.identity?.name ?? user?.name,
+                                bio: profile?.identity?.bio ?? user?.intro ?? undefined,
+                                location: profile?.identity?.location ?? user?.location ?? undefined,
+                            },
+                        },
+                    };
+                }));
+                const isChatPath = !!state.options?.conversationId;
+                const maxTurns = isChatPath
+                    ? Number(process.env.NEGOTIATION_MAX_TURNS_CHAT) || 4
+                    : Number(process.env.NEGOTIATION_MAX_TURNS_AMBIENT) || 6;
+                // Fetch per-candidate index context (group by networkId to avoid duplicate lookups)
+                const uniqueIndexIds = [...new Set(candidates.map(c => c.networkId).filter((id) => !!id))];
+                const indexContextMap = new Map();
+                await Promise.all(uniqueIndexIds.map(async (networkId) => {
+                    const ctx = await this.database.getNetworkMemberContext(networkId, discoveryUserId).catch(() => null);
+                    const prompt = [ctx?.indexPrompt, ctx?.memberPrompt]
+                        .filter((v) => !!v?.trim())
+                        .join('\n\n');
+                    if (prompt)
+                        indexContextMap.set(networkId, prompt);
+                }));
+                // Decide turn timeout.
+                //   - Background/queue path (no conversationId): always the park-window
+                //     budget (AMBIENT_PARK_WINDOW_MS, 5 min). Turns park in
+                //     `waiting_for_agent` and are picked up via polling; the dispatcher
+                //     additionally short-circuits to the system agent when no personal
+                //     agent has a fresh heartbeat (see AgentDispatcherImpl).
+                //   - Chat path with a personal agent authorized: use the same park-window
+                //     so the dispatcher parks the turn and the user's personal agent can
+                //     pick it up via polling.
+                //   - Chat path with no personal agent: use a short timeout (30s) so the
+                //     system `Index Negotiator` kicks in without stalling the chat.
+                // Check the personal agent per unique candidate network so cross-network
+                // chat runs don't get a single authorized agent deciding the timeout for
+                // every candidate. Only use the long (polling) timeout when an external
+                // (poller) agent is authorized on ALL candidate networks; otherwise fall
+                // back to the short timeout so chats don't stall on a network where only
+                // the system negotiator is allowed.
+                const hasExternalAgent = isChatPath && this.agentDispatcher
+                    ? (uniqueIndexIds.length > 0
+                        ? (await Promise.all(uniqueIndexIds.map((networkId) => this.agentDispatcher.hasExternalAgent(discoveryUserId, { action: 'manage:negotiations', scopeType: 'network', scopeId: networkId }).catch(() => false)))).every(Boolean)
+                        : false)
+                    : false;
+                // Orchestrator (chat-driven a2h) fan-out uses a tight 60s park window —
+                // the user is watching the stream, so we cannot afford the 5-min ambient
+                // budget. Ambient keeps its heartbeat-aware long/short split.
+                const ORCHESTRATOR_PARK_WINDOW_MS = 60000;
+                const isOrchestrator = state.trigger === 'orchestrator';
+                const useLongTimeout = !isChatPath || hasExternalAgent;
+                const timeoutMs = isOrchestrator
+                    ? ORCHESTRATOR_PARK_WINDOW_MS
+                    : useLongTimeout ? AMBIENT_PARK_WINDOW_MS : 30000;
+                logger.info('negotiateNode timeout decision', {
+                    discoveryUserId,
+                    trigger: state.trigger,
+                    isChatPath,
+                    isOrchestrator,
+                    hasDispatcher: !!this.agentDispatcher,
+                    hasExternalAgent,
+                    useLongTimeout,
+                    timeoutMs,
+                    candidateCount: candidates.length,
+                });
+                // Per-candidate hook — always-on. Accumulates negotiation resolutions
+                // for discovery question generation. Additionally, for the orchestrator
+                // trigger: flips the opp from 'pending' to 'draft' and pushes an
+                // `opportunity_draft_ready` event so the frontend can render it
+                // inline as soon as it resolves, rather than waiting for the full
+                // fan-out. Abort (e.g. user closed the chat) suppresses both the
+                // status flip and the event — the in-flight negotiation finishes
+                // naturally but its card never reaches the user.
+                // Build a stable order index so that resolutions accumulated via the
+                // per-candidate async hook can be re-sorted to candidate-list order
+                // before being handed to buildQuestionPrompt. Without this the LLM
+                // sees negotiations in completion-time order (non-deterministic).
+                const candidateOrderById = new Map();
+                candidates.forEach((c, i) => candidateOrderById.set(c.userId, i));
+                const resolutions = [];
+                const resolvedOpportunityIds = new Set();
+                const onCandidateResolved = async ({ candidate, accepted, turns, outcome }) => {
+                    if (candidate.opportunityId)
+                        resolvedOpportunityIds.add(candidate.opportunityId);
+                    resolutions.push({
+                        __order: candidateOrderById.get(candidate.userId) ?? Number.MAX_SAFE_INTEGER,
+                        candidateUserId: candidate.userId,
+                        counterpartyHint: (() => {
+                            const bio = candidate.candidateUser.profile?.bio?.trim();
+                            if (bio)
+                                return bio;
+                            return (candidate.candidateUser.profile?.interests ?? []).join(", ");
+                        })(),
+                        indexContext: candidate.networkId
+                            ? indexContextMap.get(candidate.networkId) ?? ""
+                            : "",
+                        turns,
+                        outcome,
+                    });
+                    if (candidate.opportunityId) {
+                        await compensateTasklessNegotiatingOpportunity(candidate.opportunityId);
+                    }
+                    if (state.trigger !== 'orchestrator')
+                        return;
+                    // ─── orchestrator streaming body ───
+                    const abortSignal = requestContext.getStore()?.abortSignal;
+                    if (abortSignal?.aborted)
+                        return;
+                    if (!accepted || !candidate.opportunityId)
+                        return;
+                    // Only emit after a successful status flip — the frontend keys
+                    // cards off `opportunity.status === 'draft'`, so emitting a row
+                    // with its pre-flip status would render inconsistently. If the
+                    // flip fails we log and drop the event; the negotiation result
+                    // is still captured in acceptedResults for the final summary.
+                    const updated = await this.database
+                        .updateOpportunityStatus(candidate.opportunityId, 'draft')
+                        .catch((err) => {
+                        negotiateLog.warn('failed to flip opp to draft; suppressing draft-ready event', {
+                            opportunityId: candidate.opportunityId,
+                            error: err,
+                        });
+                        return null;
+                    });
+                    if (!updated || abortSignal?.aborted)
+                        return;
+                    const counterpartName = candidate.candidateUser.profile?.name ?? '';
+                    const viewerName = sourceUser.profile.name;
+                    const rawReasoning = updated.interpretation?.reasoning ?? '';
+                    const personalizedSummary = safeFallbackSummary(rawReasoning, {
+                        counterpartName,
+                        viewerName,
+                        emptyText: 'A suggested connection.',
+                    });
+                    traceEmitter?.({
+                        type: 'opportunity_draft_ready',
+                        opportunityId: candidate.opportunityId,
+                        opportunity: {
+                            ...updated,
+                            interpretation: {
+                                ...updated.interpretation,
+                                reasoning: personalizedSummary,
+                            },
+                        },
+                        personalizedSummary,
+                        counterparty: {
+                            userId: candidate.candidateUser.id,
+                            ...(candidate.candidateUser.profile?.name
+                                ? { name: candidate.candidateUser.profile.name }
+                                : {}),
+                        },
+                    });
+                };
+                const negotiationWork = negotiateCandidates(this.negotiationGraph, sourceUser, candidates, { networkId: '', prompt: '' }, // base context, overridden per-candidate below
+                { maxTurns, traceEmitter: traceEmitter ?? undefined,
+                    indexContextOverrides: indexContextMap,
+                    timeoutMs,
+                    trigger: state.trigger === 'orchestrator' ? 'orchestrator' : 'ambient',
+                    // v2 initiator stamp: every fresh-discovery origin resolves to the
+                    // discovery user — querying user (chat/tool), intent owner
+                    // (from-intent), enriched user (from-enrichment/discovery-run), or
+                    // represented user (from-introducer, via onBehalfOfUserId).
+                    initiatorUserId: discoveryUserId,
+                    onCandidateResolved });
+                // MCP-only: race the whole negotiate phase against a budget. When the
+                // timer wins we return early with a `timed_out` trace; the unresolved
+                // promise keeps running in the Bun event loop and each candidate's
+                // finalize node updates its opp status in the DB. We deliberately do
+                // NOT await it, NOT abort it, and NOT mutate state.opportunities —
+                // the MCP tool handler refreshes statuses from the DB before
+                // responding. Bounded blast radius: at most ~20 s of background work
+                // per request; orphans heal via maintenance scripts or IND-279 when
+                // it lands.
+                const budgetMs = state.options.negotiateTimeoutMs;
+                let acceptedResults;
+                if (budgetMs !== undefined) {
+                    let timerId;
+                    const timerWork = new Promise((resolve) => {
+                        timerId = setTimeout(() => resolve(NEGOTIATE_TIMER_SENTINEL), budgetMs);
+                    });
+                    // try/finally ensures the timer is cleared on every exit path —
+                    // sentinel-win, work-win, AND `negotiationWork` rejection. Without
+                    // this, a rejected negotiation would leave the timer pending and
+                    // keep the event loop alive until `budgetMs` elapses.
+                    let raced;
+                    try {
+                        raced = await Promise.race([negotiationWork, timerWork]);
+                    }
+                    finally {
+                        if (timerId !== undefined)
+                            clearTimeout(timerId);
+                    }
+                    if (raced === NEGOTIATE_TIMER_SENTINEL) {
+                        // Restore any attempt that is still before its task boundary. A running or
+                        // parked negotiation already has a task and makes the CAS a no-op; a hung
+                        // pre-task init becomes owner-actionable while its floating work may retry.
+                        await Promise.all(candidates
+                            .filter((candidate) => candidate.opportunityId && !resolvedOpportunityIds.has(candidate.opportunityId))
+                            .map((candidate) => compensateTasklessNegotiatingOpportunity(candidate.opportunityId)));
+                        // Floating promise is intentional — see comment above.
+                        void negotiationWork.catch((err) => {
+                            negotiateLog.warn('background negotiation failed after timer fired', { error: err });
+                        });
+                        negotiateLog.warn('timed out — returning partial results to caller', {
+                            discoveryUserId,
+                            candidateCount: candidates.length,
+                            negotiateTimeoutMs: budgetMs,
+                        });
+                        traceEmitter?.({ type: "graph_end", name: "Negotiation graph", durationMs: Date.now() - graphStart });
+                        const orderedResolutionsPartial = [...resolutions]
+                            .sort((a, b) => a.__order - b.__order)
+                            .map(({ __order: _o, ...r }) => r);
+                        const discoveryNegotiationsPartial = orderedResolutionsPartial.map(toDiscoveryNegotiation);
+                        const discoverySummaryPartial = buildDiscoverySummary(orderedResolutionsPartial);
+                        return {
+                            trace: [{
+                                    node: 'negotiate',
+                                    detail: 'timed_out',
+                                    data: {
+                                        negotiateTimeoutMs: budgetMs,
+                                        candidateCount: candidates.length,
+                                        durationMs: Date.now() - graphStart,
+                                    },
+                                }],
+                            discoveryNegotiations: discoveryNegotiationsPartial,
+                            discoverySummary: discoverySummaryPartial,
+                        };
+                    }
+                    acceptedResults = raced;
+                }
+                else {
+                    acceptedResults = await negotiationWork;
+                }
+                // No filtering: every candidate's outcome (accept/reject/stalled) was applied to its
+                // opportunity row by the negotiation graph's finalize node via the opportunityId we
+                // passed. state.opportunities stays as it was at persist time; DB has the new statuses.
+                const acceptedUserIds = new Set(acceptedResults.map(r => r.userId));
+                const negotiationDurationMs = Date.now() - graphStart;
+                const candidateTraceEntries = candidates.map(c => {
+                    const accepted = acceptedUserIds.has(c.userId);
+                    const result = accepted ? acceptedResults.find(r => r.userId === c.userId) : null;
+                    const name = c.candidateUser.profile?.name ?? c.userId;
+                    const outcome = accepted ? 'accepted' : 'rejected_or_stalled';
+                    return {
+                        node: 'negotiate_candidate',
+                        detail: `${name}: ${outcome}`,
+                        data: {
+                            userId: c.userId,
+                            opportunityId: c.opportunityId,
+                            name,
+                            outcome,
+                            turns: result?.turnCount ?? 0,
+                        },
+                    };
+                });
+                const acceptedCount = acceptedResults.length;
+                const otherCount = candidates.length - acceptedCount;
+                const negotiateTrace = [
+                    {
+                        node: 'negotiate',
+                        detail: `${candidates.length} candidate(s) -> ${acceptedCount} accepted, ${otherCount} rejected/stalled`,
+                        data: {
+                            durationMs: negotiationDurationMs,
+                            candidateCount: candidates.length,
+                            acceptedCount,
+                            otherCount,
+                        },
+                    },
+                    ...candidateTraceEntries,
+                ];
+                traceEmitter?.({ type: "graph_end", name: "Negotiation graph", durationMs: Date.now() - graphStart });
+                const orderedResolutions = [...resolutions]
+                    .sort((a, b) => a.__order - b.__order)
+                    .map(({ __order: _o, ...r }) => r);
+                const discoveryNegotiations = orderedResolutions.map(toDiscoveryNegotiation);
+                const discoverySummary = buildDiscoverySummary(orderedResolutions);
+                return {
+                    trace: negotiateTrace,
+                    discoveryNegotiations,
+                    discoverySummary,
+                };
+            }
+            catch (err) {
+                await Promise.all(state.opportunities.map((opportunity) => compensateTasklessNegotiatingOpportunity(opportunity.id)));
+                negotiateLog.error("Negotiation stage failed", { error: err });
+                traceEmitter?.({ type: "graph_end", name: "Negotiation graph", durationMs: Date.now() - graphStart });
+                return {
+                    trace: [{
+                            node: 'negotiate',
+                            detail: 'Negotiation failed',
+                            data: { durationMs: Date.now() - graphStart, error: true },
+                        }],
+                    discoveryNegotiations: [],
+                    discoverySummary: buildDiscoverySummary([]),
+                };
+            }
+        };
+        /**
+         * Node 4: Ranking
+         * Sorts evaluated opportunities by score, applies limit, dedupes by actor-set hash.
+         */
+        const rankingNode = withNodeTrace("opportunity-ranking", async (state) => {
+            return timed("OpportunityGraph.ranking", async () => {
+                rankingLog.verbose('Starting ranking', {
+                    evaluatedCount: state.evaluatedOpportunities.length,
+                });
+                try {
+                    const sorted = [...state.evaluatedOpportunities].sort((a, b) => b.score - a.score);
+                    const limit = state.options.limit ?? 20;
+                    const ranked = sorted.slice(0, limit);
+                    const actorSetKey = (opp) => opp.actors
+                        .map((a) => `${a.userId}:${a.networkId}`)
+                        .sort()
+                        .join('|');
+                    const seen = new Set();
+                    const deduplicated = ranked.filter((opp) => {
+                        const key = actorSetKey(opp);
+                        if (seen.has(key))
+                            return false;
+                        seen.add(key);
+                        return true;
+                    });
+                    rankingLog.verbose('Ranking complete', {
+                        sorted: sorted.length,
+                        afterLimit: ranked.length,
+                        afterDedup: deduplicated.length,
+                    });
+                    return { evaluatedOpportunities: deduplicated };
+                }
+                catch (error) {
+                    const errMsg = error instanceof Error ? error.message : String(error);
+                    rankingLog.error('Failed', { error });
+                    return {
+                        evaluatedOpportunities: [],
+                        error: 'Failed to rank opportunities.',
+                        trace: [{
+                                node: "ranking_fatal",
+                                detail: `Ranking failed: ${errMsg}`,
+                                data: { error: errMsg },
+                            }],
+                    };
+                }
+            });
+        }, (result) => {
+            const r = result;
+            if (r?.error)
+                return `error: ${r.error}`;
+            const opps = r?.evaluatedOpportunities;
+            return opps ? `Ranked ${opps.length} opportunity(ies)` : undefined;
+        });
+        /**
+         * Node: intro_validation (create_introduction path)
+         * Validates network scope, membership for introducer and all party users, and no existing opportunity.
+         */
+        const introValidationNode = async (state) => {
+            return timed("OpportunityGraph.introValidation", async () => {
+                introValidationLog.verbose('Starting', {
+                    userId: state.userId,
+                    networkId: state.networkId,
+                    entitiesCount: state.introductionEntities?.length ?? 0,
+                });
+                try {
+                    const entities = state.introductionEntities ?? [];
+                    const primaryNetworkId = (state.networkId ?? entities[0]?.networkId);
+                    const partyUserIds = [...new Set(entities.map((e) => e.userId).filter((id) => id !== state.userId))];
+                    if (!primaryNetworkId || partyUserIds.length < 1) {
+                        return {
+                            error: 'Introduction requires networkId and at least two entities (introducer + one counterpart).',
+                        };
+                    }
+                    if (state.requiredNetworkId && primaryNetworkId !== state.requiredNetworkId) {
+                        return {
+                            error: 'This chat is scoped to a different community. You can only introduce members of the current community.',
+                        };
+                    }
+                    const [introducerIsMember, introducerIsOwner] = await Promise.all([
+                        this.database.isNetworkMember(primaryNetworkId, state.userId),
+                        this.database.isIndexOwner(primaryNetworkId, state.userId),
+                    ]);
+                    if (!introducerIsMember && !introducerIsOwner) {
+                        return {
+                            error: 'One or more users are not members of the specified community. You can only introduce members who share a network.',
+                        };
+                    }
+                    const partyInScope = await Promise.all(partyUserIds.map(async (userId) => {
+                        const [isMember, isOwner] = await Promise.all([
+                            this.database.isNetworkMember(primaryNetworkId, userId),
+                            this.database.isIndexOwner(primaryNetworkId, userId),
+                        ]);
+                        return isMember || isOwner;
+                    }));
+                    const allPartyMembers = partyInScope.every(Boolean);
+                    if (!allPartyMembers) {
+                        return {
+                            error: 'One or more users are not members of the specified community. You can only introduce members who share a network.',
+                        };
+                    }
+                    const exists = await this.database.opportunityExistsBetweenActors(partyUserIds, primaryNetworkId);
+                    if (exists) {
+                        return { error: 'An opportunity already exists between these people.' };
+                    }
+                    introValidationLog.verbose('Validation passed');
+                    return {};
+                }
+                catch (err) {
+                    const errMsg = err instanceof Error ? err.message : String(err);
+                    introValidationLog.error('Failed', {
+                        userId: state.userId,
+                        networkId: state.networkId,
+                        error: err,
+                    });
+                    return {
+                        error: 'Introduction validation failed.',
+                        trace: [{
+                                node: "intro_validation_fatal",
+                                detail: `IntroValidation failed: ${errMsg}`,
+                                data: { error: errMsg },
+                            }],
+                    };
+                }
+            });
+        };
+        /**
+         * Build fallback reasoning and actors when evaluator returns empty or throws.
+         */
+        function buildIntroFallback(entities, state, primaryNetworkId, introducerName) {
+            const reasoning = `${introducerName ?? 'A member'} believes these people should connect.` +
+                (state.introductionHint ? ` Context: ${state.introductionHint}` : '');
+            const score = 70;
+            const partyUserIds = entities.map((e) => e.userId).filter((id) => id !== state.userId);
+            const actors = partyUserIds.map((uid) => ({
+                userId: uid,
+                role: 'peer',
+                networkId: primaryNetworkId,
+            }));
+            return { reasoning, score, actors };
+        }
+        /**
+         * Node: intro_evaluation (create_introduction path)
+         * Runs entity-bundle evaluator and sets evaluatedOpportunities (one) + introductionContext.
+         */
+        const introEvaluationNode = async (state) => {
+            return timed("OpportunityGraph.introEvaluation", async () => {
+                introEvaluationLog.verbose('Starting', { userId: state.userId });
+                if (state.error) {
+                    return { evaluatedOpportunities: [], agentTimings: [] };
+                }
+                const entities = state.introductionEntities ?? [];
+                const primaryNetworkId = (state.networkId ?? entities[0]?.networkId);
+                if (!primaryNetworkId || entities.length < 2) {
+                    return { evaluatedOpportunities: [], error: 'Missing entities or network for introduction.', agentTimings: [] };
+                }
+                const agentTimingsAccum = [];
+                let introducerName;
+                let reasoning;
+                let score;
+                let actors = [];
+                const _traceEmitterIntro = requestContext.getStore()?.traceEmitter;
+                let _introEvalStarted = false;
+                let _evalStart = Date.now();
+                try {
+                    const introducerUser = await this.database.getUser(state.userId);
+                    introducerName = introducerUser?.name ?? undefined;
+                    const networkContexts = await buildNetworkContexts(entities, this.database);
+                    const input = {
+                        discovererId: state.userId,
+                        entities,
+                        introductionMode: true,
+                        introducerName,
+                        introductionHint: state.introductionHint ?? undefined,
+                        networkContexts,
+                    };
+                    _evalStart = Date.now();
+                    _traceEmitterIntro?.({ type: "agent_start", name: "intro-evaluator" });
+                    _introEvalStarted = true;
+                    const evaluated = await evaluatorAgent.invokeEntityBundle(input, { minScore: 0 });
+                    const _introDuration = Date.now() - _evalStart;
+                    agentTimingsAccum.push({ name: 'opportunity.evaluator', durationMs: _introDuration });
+                    _traceEmitterIntro?.({ type: "agent_end", name: "intro-evaluator", durationMs: _introDuration, summary: "Evaluated introduction" });
+                    if (evaluated.length > 0) {
+                        const best = evaluated[0];
+                        reasoning = best.reasoning;
+                        score = best.score;
+                        actors = best.actors.map((a) => ({
+                            userId: a.userId,
+                            role: a.role,
+                            intentId: a.intentId ?? undefined,
+                            networkId: primaryNetworkId,
+                        }));
+                    }
+                    else {
+                        const fallback = buildIntroFallback(entities, state, primaryNetworkId, introducerName);
+                        reasoning = fallback.reasoning;
+                        score = fallback.score;
+                        actors = fallback.actors;
+                    }
+                }
+                catch (evalErr) {
+                    const errMsg = evalErr instanceof Error ? evalErr.message : String(evalErr);
+                    // Close the intro-evaluator span if it was started before the error
+                    if (_introEvalStarted) {
+                        const _introErrDuration = Date.now() - _evalStart;
+                        _traceEmitterIntro?.({ type: "agent_end", name: "intro-evaluator", durationMs: _introErrDuration, summary: `error — ${errMsg}` });
+                        agentTimingsAccum.push({ name: 'opportunity.evaluator', durationMs: _introErrDuration });
+                    }
+                    introEvaluationLog.warn('Evaluator or getUser failed, using fallback', { error: evalErr });
+                    const fallback = buildIntroFallback(entities, state, primaryNetworkId, introducerName);
+                    reasoning = fallback.reasoning;
+                    score = fallback.score;
+                    actors = fallback.actors;
+                    return {
+                        evaluatedOpportunities: [{ actors, score, reasoning }],
+                        introductionContext: { createdByName: introducerName },
+                        options: { ...state.options, initialStatus: state.options.initialStatus ?? 'latent' },
+                        agentTimings: agentTimingsAccum,
+                        trace: [{
+                                node: "intro_evaluation_fatal",
+                                detail: `IntroEvaluation failed (using fallback): ${errMsg}`,
+                                data: { error: errMsg },
+                            }],
+                    };
+                }
+                const evaluatedOpportunity = {
+                    actors,
+                    score,
+                    reasoning,
+                };
+                return {
+                    evaluatedOpportunities: [evaluatedOpportunity],
+                    introductionContext: { createdByName: introducerName },
+                    options: { ...state.options, initialStatus: state.options.initialStatus ?? 'latent' },
+                    agentTimings: agentTimingsAccum,
+                };
+            });
+        };
+        /**
+         * Node 5: Persist
+         * Creates opportunities from evaluator-proposed actors (networkId, userId, role, optional intent).
+         */
+        const persistNode = withNodeTrace("opportunity-persist", async (state) => {
+            return timed("OpportunityGraph.persist", async () => {
+                const startTime = Date.now();
+                const initialStatus = resolveInitialStatus(state.trigger, state.options.initialStatus);
+                persistLog.verbose('Starting persistence (dedup-v2)', {
+                    opportunitiesToCreate: state.evaluatedOpportunities.length,
+                    trigger: state.trigger,
+                    initialStatus,
+                });
+                if (state.evaluatedOpportunities.length === 0) {
+                    persistLog.verbose('No opportunities to persist', {
+                        triggerIntentId: state.triggerIntentId,
+                        reason: state.candidates.length === 0 ? 'no_search_candidates' : 'evaluator_rejected_all',
+                    });
+                    return {
+                        opportunities: [],
+                        persistenceOutcome: {
+                            evaluatedCount: 0,
+                            createdCount: 0,
+                            reactivatedCount: 0,
+                            sameTriggerDuplicateSuppressions: 0,
+                            pairActiveNegotiationSuppressions: 0,
+                            crossTriggerAllowedCount: 0,
+                            finalAtomicConflictCount: 0,
+                        },
+                    };
+                }
+                try {
+                    const finalTriggerIntentId = state.triggerIntentId;
+                    const admission = await admitOpportunityPersistence(this.database, {
+                        ownerUserId: state.userId,
+                        triggerIntentId: finalTriggerIntentId,
+                        networkId: state.networkId,
+                        indexScope: state.indexScope,
+                        evaluatedOpportunities: state.evaluatedOpportunities,
+                    });
+                    if (admission.kind === 'empty_scope') {
+                        persistLog.info('Skipped persistence because final discovery scope is empty', {
+                            userId: state.userId,
+                            triggerIntentId: finalTriggerIntentId,
+                        });
+                        return { opportunities: [] };
+                    }
+                    const { allowedNetworkIds: finalAllowedNetworkIds, networkEligibility, evaluatedOpportunities: evaluatedToPersist } = admission;
+                    if (evaluatedToPersist.length < state.evaluatedOpportunities.length) {
+                        persistLog.info('Skipped opportunities with inactive participant network pairs', {
+                            before: state.evaluatedOpportunities.length,
+                            after: evaluatedToPersist.length,
+                            removed: state.evaluatedOpportunities.length - evaluatedToPersist.length,
+                        });
+                    }
+                    if (evaluatedToPersist.length === 0)
+                        return { opportunities: [] };
+                    const updateStatusIfStillEligible = createEligibleOpportunityStatusUpdater(this.database, finalAllowedNetworkIds, networkEligibility, {
+                        onUnavailableAdapter: () => {
+                            persistLog.error('Network-eligible status update adapter is unavailable; failing closed');
+                        },
+                    });
+                    const itemsToPersist = [];
+                    const reactivatedOpportunities = [];
+                    let crossTriggerAllowedCount = 0;
+                    const existingBetweenActors = [];
+                    const now = new Date().toISOString();
+                    // Only skip 'draft' (chat-only) opportunities during dedup.
+                    // 'latent' must NOT be skipped — background discovery creates latent opportunities,
+                    // and excluding them causes the same user pair to get duplicate opportunities
+                    // when multiple intents trigger separate discovery jobs (IND-166).
+                    const DEDUP_SKIP_STATUSES = ['draft'];
+                    const introducerUserForOnBehalf = state.onBehalfOfUserId
+                        ? await this.database.getUser(state.userId)
+                        : null;
+                    // Orchestrator-only: collect already-accepted pairs so Task 7's
+                    // discover_opportunities tool can tell the LLM "these pairs are
+                    // already connected, surface the existing chat rather than
+                    // creating a new draft". Runs in parallel across unique
+                    // counterparties (a single evaluator pass can return multiple
+                    // opps per counterparty; we only hit the DB once per pair).
+                    // Failures are swallowed — the per-pair query is best-effort.
+                    const dedupAlreadyAccepted = [];
+                    if (state.trigger === 'orchestrator') {
+                        // Use the same viewer-resolution as evaluation/negotiate/persist
+                        // on-behalf branches so an introducer-driven orchestrator run
+                        // queries accepted opps between the *target* user and the
+                        // counterparty, not between the introducer and the counterparty.
+                        const dedupUserId = (state.onBehalfOfUserId ?? state.userId);
+                        const uniqueCounterparts = new Set();
+                        for (const evaluated of evaluatedToPersist) {
+                            const candidateUserId = evaluated.actors.find(a => a.userId !== dedupUserId)?.userId;
+                            if (candidateUserId)
+                                uniqueCounterparts.add(candidateUserId);
+                        }
+                        const lookups = await Promise.all([...uniqueCounterparts].map(async (counterpartyUserId) => {
+                            const accepted = await this.database
+                                .findOpportunitiesByActors([dedupUserId, counterpartyUserId], { includeIntroducers: true, statuses: ['accepted'] })
+                                .catch((err) => {
+                                persistLog.warn('findOpportunitiesByActors (sibling-accept) failed', {
+                                    userId: dedupUserId,
+                                    counterpartyUserId,
+                                    error: err,
+                                });
+                                return [];
+                            });
+                            return accepted.map((opp) => ({ opportunityId: opp.id, counterpartyUserId }));
+                        }));
+                        dedupAlreadyAccepted.push(...lookups.flat());
+                    }
+                    for (const evaluated of evaluatedToPersist) {
+                        const indexIdForActors = state.networkId ?? evaluated.actors[0]?.networkId;
+                        let actors;
+                        let data;
+                        persistPathLog.verbose('Selecting persistence path', {
+                            isIntroduction: !!state.introductionContext,
+                            stateUserId: state.userId,
+                            stateIndexId: state.networkId,
+                            evaluatedActorUserIds: evaluated.actors.map(a => a.userId),
+                        });
+                        if (state.introductionContext) {
+                            if (indexIdForActors === undefined) {
+                                persistLog.warn('Introduction path missing networkId; skipping opportunity', {
+                                    userId: state.userId,
+                                    actorsCount: evaluated.actors.length,
+                                });
+                                continue;
+                            }
+                            // Introduction path: manual detection, introducer actor, curator_judgment signal.
+                            const evaluatorActors = evaluated.actors.map((a) => {
+                                const intent = normalizeOpportunityActorIntent(a.intentId);
+                                return {
+                                    networkId: a.networkId ?? indexIdForActors,
+                                    userId: a.userId,
+                                    role: a.role,
+                                    ...(intent ? { intent: intent } : {}),
+                                };
+                            });
+                            const viewerAlreadyInActors = evaluatorActors.some(a => a.userId === state.userId);
+                            actors = viewerAlreadyInActors
+                                ? evaluatorActors
+                                : [
+                                    ...evaluatorActors,
+                                    { networkId: indexIdForActors, userId: state.userId, role: 'introducer', approved: false },
+                                ];
+                            data = {
+                                detection: {
+                                    source: 'manual',
+                                    createdBy: state.userId,
+                                    createdByName: state.introductionContext.createdByName,
+                                    timestamp: now,
+                                },
+                                actors,
+                                interpretation: {
+                                    category: 'collaboration',
+                                    reasoning: evaluated.reasoning,
+                                    confidence: evaluated.score / 100,
+                                    signals: [
+                                        {
+                                            type: 'curator_judgment',
+                                            weight: 1,
+                                            detail: `Introduction by ${state.introductionContext.createdByName ?? 'a member'} via chat`,
+                                        },
+                                    ],
+                                },
+                                context: {
+                                    networkId: state.networkId ?? indexIdForActors,
+                                    ...(state.options.conversationId ? { conversationId: state.options.conversationId } : {}),
+                                },
+                                confidence: String(evaluated.score / 100),
+                                status: initialStatus,
+                            };
+                        }
+                        else if (state.onBehalfOfUserId) {
+                            if (indexIdForActors === undefined) {
+                                persistLog.warn('Introducer discovery path missing networkId; skipping opportunity', {
+                                    userId: state.userId,
+                                    actorsCount: evaluated.actors.length,
+                                });
+                                continue;
+                            }
+                            // Introducer discovery path: introducer is state.userId, target is onBehalfOfUserId.
+                            const evaluatorActors = evaluated.actors.map((a) => {
+                                const intent = normalizeOpportunityActorIntent(a.intentId);
+                                return {
+                                    networkId: a.networkId ?? indexIdForActors,
+                                    userId: a.userId,
+                                    role: a.role,
+                                    ...(intent ? { intent: intent } : {}),
+                                };
+                            });
+                            const viewerAlreadyInActors = evaluatorActors.some(a => a.userId === state.userId);
+                            actors = viewerAlreadyInActors
+                                ? evaluatorActors
+                                : [
+                                    ...evaluatorActors,
+                                    { networkId: indexIdForActors, userId: state.userId, role: 'introducer', approved: false },
+                                ];
+                            const candidateUserId = evaluated.actors.find((a) => a.userId !== state.onBehalfOfUserId)?.userId;
+                            const overlapping = candidateUserId
+                                ? await this.database.findOpportunitiesByActors([state.onBehalfOfUserId, candidateUserId], { excludeStatuses: DEDUP_SKIP_STATUSES })
+                                : [];
+                            if (overlapping.length > 0) {
+                                const existing = overlapping[0];
+                                const isRecent = new Date(existing.createdAt).getTime() > Date.now() - DEDUP_WINDOW_MS;
+                                const sameIntroducer = existing.actors?.some((actor) => actor.role === 'introducer' && actor.userId === state.userId);
+                                if (existing.status === 'expired' || existing.status === 'stalled') {
+                                    // Reactivate expired or stalled opportunities (only if same introducer for expired).
+                                    // A different introducer creating for an expired pair falls through to new creation —
+                                    // the prior expiry belongs to the original introducer, not this one.
+                                    // Stalled opportunities are reactivated regardless of age: a stalled negotiation
+                                    // is still in-flight for this pair, so we resume it rather than create a parallel one.
+                                    if (existing.status === 'stalled' || sameIntroducer) {
+                                        // Introduction path always targets 'draft' (chat-only surface) rather than using
+                                        // initialStatus, because introductions are always chat-initiated, not background-discovered.
+                                        const reactivated = await updateStatusIfStillEligible(existing.id, 'draft', existing.actors, existing.status);
+                                        if (reactivated) {
+                                            persistLog.verbose('Reactivated opportunity (introduction path)', {
+                                                opportunityId: existing.id,
+                                                candidateUserId,
+                                                previousStatus: existing.status,
+                                            });
+                                            reactivatedOpportunities.push(reactivated);
+                                        }
+                                        continue;
+                                    }
+                                }
+                                else if (existing.status === 'negotiating') {
+                                    // Orphan heal (introduction path): same logic as discovery path
+                                    const priorTask = await this.database.getNegotiationTaskForOpportunity(existing.id);
+                                    if (priorTask && isActiveNegotiationTaskFresh(priorTask)) {
+                                        existingBetweenActors.push({
+                                            candidateUserId: candidateUserId,
+                                            networkId: (state.networkId ?? indexIdForActors ?? ''),
+                                            existingOpportunityId: existing.id,
+                                            existingStatus: existing.status,
+                                        });
+                                        persistLog.verbose('Skipping negotiating opportunity with active task (introduction path)', {
+                                            opportunityId: existing.id,
+                                            candidateUserId,
+                                            taskState: priorTask.state,
+                                        });
+                                        continue;
+                                    }
+                                    const reactivated = await updateStatusIfStillEligible(existing.id, 'draft', existing.actors, existing.status);
+                                    if (reactivated) {
+                                        persistLog.info('Resuming orphaned negotiating opportunity (introduction path)', {
+                                            opportunityId: existing.id,
+                                            candidateUserId,
+                                            priorTaskState: priorTask?.state,
+                                        });
+                                        reactivatedOpportunities.push(reactivated);
+                                    }
+                                    continue;
+                                }
+                                else if (existing.status === 'latent') {
+                                    // Upgrade latent to draft for introduction path
+                                    const upgraded = await updateStatusIfStillEligible(existing.id, 'draft', existing.actors, existing.status);
+                                    if (upgraded) {
+                                        persistLog.verbose('Upgraded latent opportunity to draft (introduction path)', {
+                                            opportunityId: existing.id,
+                                            candidateUserId,
+                                        });
+                                        reactivatedOpportunities.push(upgraded);
+                                    }
+                                    continue;
+                                }
+                                else if (isRecent && candidateUserId) {
+                                    // Time-gated skip: only skip if opportunity was created within DEDUP_WINDOW_MS
+                                    existingBetweenActors.push({
+                                        candidateUserId: candidateUserId,
+                                        networkId: (state.networkId ?? indexIdForActors ?? ''),
+                                        existingOpportunityId: existing.id,
+                                        existingStatus: existing.status,
+                                    });
+                                    persistLog.verbose('Skipping recent duplicate (introduction path)', {
+                                        candidateUserId,
+                                        existingStatus: existing.status,
+                                        existingOpportunityId: existing.id,
+                                    });
+                                    continue;
+                                }
+                                // Else: existing opportunity is old enough, allow new opportunity creation
+                                persistLog.verbose('Allowing new opportunity; existing is outside dedup window (introduction path)', {
+                                    candidateUserId,
+                                    existingStatus: existing.status,
+                                    existingOpportunityId: existing.id,
+                                });
+                            }
+                            data = {
+                                detection: {
+                                    source: INTRODUCER_DISCOVERY_SOURCE,
+                                    createdBy: state.userId,
+                                    createdByName: introducerUserForOnBehalf?.name ?? undefined,
+                                    timestamp: now,
+                                },
+                                actors,
+                                interpretation: {
+                                    category: 'collaboration',
+                                    reasoning: evaluated.reasoning,
+                                    confidence: evaluated.score / 100,
+                                    signals: [{
+                                            type: 'curator_judgment',
+                                            weight: 1,
+                                            detail: `Introducer discovery for ${introducerUserForOnBehalf?.name ?? 'a member'} via background maintenance`,
+                                        }],
+                                },
+                                context: {
+                                    networkId: state.networkId ?? indexIdForActors,
+                                    ...(state.options.conversationId ? { conversationId: state.options.conversationId } : {}),
+                                },
+                                confidence: String(evaluated.score / 100),
+                                status: initialStatus,
+                            };
+                        }
+                        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.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) => {
+                                const intent = normalizeOpportunityActorIntent(a.intentId);
+                                return {
+                                    networkId: a.networkId ?? indexIdForActors,
+                                    userId: a.userId,
+                                    role: a.role,
+                                    ...(intent ? { intent: intent } : {}),
+                                    ...(premiseLookup.has(a.userId) ? { premise: premiseLookup.get(a.userId).premiseId } : {}),
+                                };
+                            });
+                            actors = evaluatorActors;
+                            const hasIntroducerActor = actors.some(a => a.role === 'introducer');
+                            if (!hasIntroducerActor) {
+                                const discovererIdx = actors.findIndex(a => a.userId === state.userId);
+                                if (discovererIdx >= 0 && actors[discovererIdx].role === 'agent') {
+                                    const counterpartIdx = actors.findIndex((a, i) => i !== discovererIdx && a.role === 'patient');
+                                    actors[discovererIdx] = { ...actors[discovererIdx], role: 'patient' };
+                                    if (counterpartIdx >= 0) {
+                                        actors[counterpartIdx] = { ...actors[counterpartIdx], role: 'agent' };
+                                    }
+                                    persistLog.verbose('Swapped discoverer from agent to patient for lifecycle visibility', {
+                                        discovererId: state.userId,
+                                    });
+                                }
+                            }
+                            // Index-agnostic dedup: find ANY existing opportunity between these users,
+                            // regardless of which index it was created in or whether a focused network scope is set.
+                            const candidateUserId = evaluated.actors.find((a) => a.userId !== state.userId)?.userId;
+                            persistDedupLog.verbose('Checking overlapping opportunities', {
+                                stateUserId: state.userId,
+                                candidateUserId: candidateUserId ?? 'NONE',
+                                evaluatedActors: evaluated.actors.map(a => ({ userId: a.userId, role: a.role })),
+                            });
+                            const overlapping = candidateUserId
+                                ? await this.database.findOpportunitiesByActors([state.userId, candidateUserId], { excludeStatuses: DEDUP_SKIP_STATUSES })
+                                : [];
+                            persistDedupLog.verbose('findOpportunitiesByActors result', {
+                                count: overlapping.length,
+                                results: overlapping.map(o => ({ id: o.id, status: o.status, actors: o.actors?.map((a) => ({ userId: a.userId, role: a.role })) })),
+                            });
+                            const ownedIntentTriggerId = state.discoverySource === 'intent'
+                                && state.triggerIntentId
+                                && state.resolvedTriggerIntentId === state.triggerIntentId
+                                ? state.triggerIntentId
+                                : undefined;
+                            if (ownedIntentTriggerId && candidateUserId) {
+                                let activeNegotiation;
+                                for (const opportunity of overlapping) {
+                                    if (opportunity.status !== 'negotiating')
+                                        continue;
+                                    const task = await this.database.getNegotiationTaskForOpportunity(opportunity.id);
+                                    if (task && isActiveNegotiationTaskFresh(task)) {
+                                        activeNegotiation = { opportunity, taskState: task.state };
+                                        break;
+                                    }
+                                }
+                                if (activeNegotiation) {
+                                    const existingTriggerIntentId = triggerForOwner(activeNegotiation.opportunity, state.userId);
+                                    existingBetweenActors.push({
+                                        candidateUserId: candidateUserId,
+                                        networkId: (activeNegotiation.opportunity.context?.networkId ?? state.networkId ?? state.userNetworks?.[0] ?? ''),
+                                        existingOpportunityId: activeNegotiation.opportunity.id,
+                                        existingStatus: activeNegotiation.opportunity.status,
+                                        reason: 'pair_active_negotiation',
+                                        ...(existingTriggerIntentId ? { existingTriggerIntentId } : {}),
+                                    });
+                                    persistDedupLog.info('Suppressing owned-intent match for pair-global active negotiation', {
+                                        triggerIntentId: ownedIntentTriggerId,
+                                        candidateUserId,
+                                        existingOpportunityId: activeNegotiation.opportunity.id,
+                                        existingTriggerIntentId,
+                                        existingStatus: activeNegotiation.opportunity.status,
+                                        existingAgeMs: Date.now() - new Date(activeNegotiation.opportunity.createdAt).getTime(),
+                                        taskState: activeNegotiation.taskState,
+                                        reason: 'pair_active_negotiation',
+                                    });
+                                    continue;
+                                }
+                                const sameTrigger = overlapping
+                                    .filter((opportunity) => belongsToOwnedIntent(opportunity, state.userId, ownedIntentTriggerId))
+                                    .sort((a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime());
+                                const otherTrigger = overlapping.filter((opportunity) => !belongsToOwnedIntent(opportunity, state.userId, ownedIntentTriggerId));
+                                const existing = sameTrigger[0];
+                                if (!existing) {
+                                    if (otherTrigger.length > 0) {
+                                        crossTriggerAllowedCount += 1;
+                                        persistDedupLog.info('Allowing cross-trigger match for owned intent', {
+                                            triggerIntentId: ownedIntentTriggerId,
+                                            candidateUserId,
+                                            reason: 'cross_trigger_match_allowed',
+                                            otherTriggers: otherTrigger.map((opportunity) => ({
+                                                opportunityId: opportunity.id,
+                                                triggerIntentId: triggerForOwner(opportunity, state.userId),
+                                                status: opportunity.status,
+                                                ageMs: Date.now() - new Date(opportunity.createdAt).getTime(),
+                                            })),
+                                        });
+                                    }
+                                }
+                                else {
+                                    const existingIndexId = (existing.context?.networkId ?? state.networkId ?? state.userNetworks?.[0] ?? '');
+                                    const isRecent = new Date(existing.createdAt).getTime() > Date.now() - DEDUP_WINDOW_MS;
+                                    if (existing.status === 'expired' || existing.status === 'stalled') {
+                                        const reactivated = await updateStatusIfStillEligible(existing.id, initialStatus, existing.actors, existing.status);
+                                        if (reactivated) {
+                                            persistLog.info('Reactivated same-trigger opportunity', {
+                                                triggerIntentId: ownedIntentTriggerId,
+                                                opportunityId: existing.id,
+                                                candidateUserId,
+                                                previousStatus: existing.status,
+                                                newStatus: initialStatus,
+                                            });
+                                            reactivatedOpportunities.push(reactivated);
+                                        }
+                                        continue;
+                                    }
+                                    if (existing.status === 'negotiating') {
+                                        const reactivated = await updateStatusIfStillEligible(existing.id, initialStatus, existing.actors, existing.status);
+                                        if (reactivated) {
+                                            persistLog.info('Resuming same-trigger orphaned negotiating opportunity', {
+                                                triggerIntentId: ownedIntentTriggerId,
+                                                opportunityId: existing.id,
+                                                candidateUserId,
+                                            });
+                                            reactivatedOpportunities.push(reactivated);
+                                        }
+                                        continue;
+                                    }
+                                    if (existing.status === 'latent' && initialStatus !== 'latent') {
+                                        const upgraded = await updateStatusIfStillEligible(existing.id, initialStatus, existing.actors, existing.status);
+                                        if (upgraded) {
+                                            persistLog.info('Upgraded same-trigger latent opportunity', {
+                                                triggerIntentId: ownedIntentTriggerId,
+                                                opportunityId: existing.id,
+                                                candidateUserId,
+                                                newStatus: initialStatus,
+                                            });
+                                            reactivatedOpportunities.push(upgraded);
+                                        }
+                                        continue;
+                                    }
+                                    if (isRecent) {
+                                        existingBetweenActors.push({
+                                            candidateUserId: candidateUserId,
+                                            networkId: existingIndexId,
+                                            existingOpportunityId: existing.id,
+                                            existingStatus: existing.status,
+                                            reason: 'same_trigger_recent_duplicate',
+                                            existingTriggerIntentId: ownedIntentTriggerId,
+                                        });
+                                        persistDedupLog.info('Suppressing recent same-trigger duplicate', {
+                                            triggerIntentId: ownedIntentTriggerId,
+                                            candidateUserId,
+                                            existingOpportunityId: existing.id,
+                                            existingTriggerIntentId: ownedIntentTriggerId,
+                                            existingStatus: existing.status,
+                                            existingAgeMs: Date.now() - new Date(existing.createdAt).getTime(),
+                                            reason: 'same_trigger_recent_duplicate',
+                                        });
+                                        continue;
+                                    }
+                                    persistDedupLog.info('Allowing same-trigger opportunity outside dedup window', {
+                                        triggerIntentId: ownedIntentTriggerId,
+                                        candidateUserId,
+                                        existingOpportunityId: existing.id,
+                                        existingStatus: existing.status,
+                                        existingAgeMs: Date.now() - new Date(existing.createdAt).getTime(),
+                                    });
+                                }
+                            }
+                            else if (overlapping.length > 0) {
+                                const existing = overlapping[0];
+                                const existingIndexId = (existing.context?.networkId ?? state.networkId ?? state.userNetworks?.[0] ?? '');
+                                const isRecent = new Date(existing.createdAt).getTime() > Date.now() - DEDUP_WINDOW_MS;
+                                if (existing.status === 'expired' || existing.status === 'stalled') {
+                                    // Reactivate expired or stalled opportunities.
+                                    // Stalled opportunities are reactivated regardless of age: a stalled negotiation
+                                    // is still in-flight for this pair, so we resume it rather than create a parallel one.
+                                    const reactivated = await updateStatusIfStillEligible(existing.id, initialStatus, existing.actors, existing.status);
+                                    if (reactivated) {
+                                        persistLog.verbose('Reactivated opportunity', {
+                                            opportunityId: existing.id,
+                                            candidateUserId,
+                                            previousStatus: existing.status,
+                                            newStatus: initialStatus,
+                                        });
+                                        reactivatedOpportunities.push(reactivated);
+                                    }
+                                    continue;
+                                }
+                                else if (existing.status === 'negotiating') {
+                                    // Orphan heal: if a prior opportunity is stuck in 'negotiating' with a stale task,
+                                    // reactivate it so the new discovery run can reuse it instead of creating a duplicate.
+                                    const priorTask = await this.database.getNegotiationTaskForOpportunity(existing.id);
+                                    if (priorTask && isActiveNegotiationTaskFresh(priorTask)) {
+                                        // Still active — skip (lock gate in init node will handle)
+                                        existingBetweenActors.push({
+                                            candidateUserId: candidateUserId,
+                                            networkId: existingIndexId,
+                                            existingOpportunityId: existing.id,
+                                            existingStatus: existing.status,
+                                        });
+                                        persistLog.verbose('Skipping negotiating opportunity with active task', {
+                                            opportunityId: existing.id,
+                                            candidateUserId,
+                                            taskState: priorTask.state,
+                                        });
+                                        continue;
+                                    }
+                                    // Task is stale or missing — reactivate the orphaned negotiating opportunity
+                                    const reactivated = await updateStatusIfStillEligible(existing.id, initialStatus, existing.actors, existing.status);
+                                    if (reactivated) {
+                                        persistLog.info('Resuming orphaned negotiating opportunity', {
+                                            opportunityId: existing.id,
+                                            candidateUserId,
+                                            priorTaskState: priorTask?.state,
+                                        });
+                                        reactivatedOpportunities.push(reactivated);
+                                    }
+                                    continue;
+                                }
+                                else if (existing.status === 'latent' && initialStatus !== 'latent') {
+                                    // Upgrade latent (background-discovered) to the higher-priority status (e.g. pending)
+                                    const upgraded = await updateStatusIfStillEligible(existing.id, initialStatus, existing.actors, existing.status);
+                                    if (upgraded) {
+                                        persistLog.verbose('Upgraded latent opportunity to higher-priority status', {
+                                            opportunityId: existing.id,
+                                            candidateUserId,
+                                            previousStatus: 'latent',
+                                            newStatus: initialStatus,
+                                        });
+                                        reactivatedOpportunities.push(upgraded);
+                                    }
+                                    continue;
+                                }
+                                else if (isRecent && candidateUserId) {
+                                    // Time-gated skip: only skip if opportunity was created within DEDUP_WINDOW_MS
+                                    // This prevents parallel job duplicates while allowing new discoveries for long-connected pairs
+                                    existingBetweenActors.push({
+                                        candidateUserId: candidateUserId,
+                                        networkId: existingIndexId,
+                                        existingOpportunityId: existing.id,
+                                        existingStatus: existing.status,
+                                    });
+                                    persistLog.verbose('Skipping recent duplicate; opportunity created within dedup window', {
+                                        candidateUserId,
+                                        existingStatus: existing.status,
+                                        existingOpportunityId: existing.id,
+                                        createdAt: existing.createdAt,
+                                    });
+                                    continue;
+                                }
+                                // Else: existing opportunity is old enough (outside the 30-day dedup window), allow new opportunity creation
+                                persistLog.verbose('Allowing new opportunity; existing is outside dedup window', {
+                                    candidateUserId,
+                                    existingStatus: existing.status,
+                                    existingOpportunityId: existing.id,
+                                    createdAt: existing.createdAt,
+                                });
+                            }
+                            data = {
+                                detection: {
+                                    source: 'opportunity_graph',
+                                    createdBy: 'agent-opportunity-finder',
+                                    ...(state.discoverySource === 'intent' && state.resolvedTriggerIntentId
+                                        ? { triggeredBy: state.resolvedTriggerIntentId }
+                                        : {}),
+                                    timestamp: now,
+                                },
+                                actors,
+                                interpretation: {
+                                    category: 'collaboration',
+                                    reasoning: evaluated.reasoning,
+                                    confidence: evaluated.score / 100,
+                                    signals: [
+                                        {
+                                            type: evaluated.actors.some((a) => a.intentId) ? 'intent_match' : 'profile_match',
+                                            weight: evaluated.score / 100,
+                                            detail: 'Entity-bundle evaluator',
+                                        },
+                                    ],
+                                },
+                                context: {
+                                    ...(state.networkId ? { networkId: state.networkId } : {}),
+                                    ...(state.options.conversationId ? { conversationId: state.options.conversationId } : {}),
+                                },
+                                confidence: String(evaluated.score / 100),
+                                status: initialStatus,
+                                metadata: {
+                                    evidence: evaluated.evidence ?? [],
+                                },
+                            };
+                        }
+                        if (hasUnsupportedOpportunityClaim(data.interpretation.reasoning)) {
+                            persistLog.warn('Skipping opportunity with unsupported affiliation/presence claim at persistence boundary', {
+                                source: data.detection.source,
+                                triggerIntentId: data.detection.triggeredBy,
+                            });
+                            continue;
+                        }
+                        try {
+                            validateOpportunityActors(data.actors);
+                        }
+                        catch (err) {
+                            persistLog.warn('Skipping opportunity with invalid actors', {
+                                error: err instanceof Error ? err.message : String(err),
+                                opportunityReasoning: evaluated.reasoning?.slice(0, 80),
+                            });
+                            continue;
+                        }
+                        itemsToPersist.push(data);
+                    }
+                    const itemsForPersistence = await stampEligibleNewbornOpportunities(itemsToPersist, {
+                        ownerUserId: state.userId,
+                        operationMode: state.operationMode,
+                        hasIntroductionContext: Boolean(state.introductionContext),
+                        onBehalfOfUserId: state.onBehalfOfUserId,
+                        targetUserId: state.targetUserId,
+                        discoverySource: state.discoverySource,
+                        resolvedTriggerIntentId: state.resolvedTriggerIntentId,
+                        indexedIntentIds: state.indexedIntents.map((intent) => intent.intentId),
+                    }, this.stampNewbornOpportunities, {
+                        onUnsafeResult: ({ expected, actual }) => {
+                            persistLog.warn('Newborn stamper returned unsafe length/order; persisting originals', { expected, actual });
+                        },
+                        onFailure: ({ intentId, error }) => {
+                            persistLog.warn('Newborn stamper failed; persisting originals', {
+                                intentId,
+                                error: error instanceof Error ? error.message : String(error),
+                            });
+                        },
+                    });
+                    const intentDedupScope = finalTriggerIntentId && state.discoverySource === 'intent'
+                        ? { triggerIntentId: finalTriggerIntentId, dedupWindowMs: DEDUP_WINDOW_MS }
+                        : undefined;
+                    const { created: createdList, conflicts } = await persistOpportunities({
+                        database: this.database,
+                        embedder: this.embedder,
+                        items: itemsForPersistence,
+                        networkEligibility,
+                        intentDedupScope,
+                    });
+                    for (const conflict of conflicts) {
+                        const item = itemsForPersistence[conflict.itemIndex];
+                        const candidateActor = item?.actors.find((actor) => actor.userId !== state.userId);
+                        if (!candidateActor)
+                            continue;
+                        existingBetweenActors.push({
+                            candidateUserId: candidateActor.userId,
+                            networkId: candidateActor.networkId,
+                            existingOpportunityId: conflict.existingOpportunityId,
+                            existingStatus: conflict.existingStatus,
+                            reason: conflict.reason,
+                            ...(conflict.existingTriggerIntentId
+                                ? { existingTriggerIntentId: conflict.existingTriggerIntentId }
+                                : {}),
+                        });
+                        persistDedupLog.info('Final atomic persistence conflict', {
+                            triggerIntentId: finalTriggerIntentId,
+                            candidateUserId: candidateActor.userId,
+                            existingOpportunityId: conflict.existingOpportunityId,
+                            existingTriggerIntentId: conflict.existingTriggerIntentId,
+                            existingStatus: conflict.existingStatus,
+                            existingAgeMs: Date.now() - new Date(conflict.existingCreatedAt).getTime(),
+                            reason: conflict.reason,
+                            finalAtomic: true,
+                        });
+                    }
+                    const allOpportunities = [...reactivatedOpportunities, ...createdList];
+                    persistLog.verbose('Persistence complete', {
+                        created: createdList.length,
+                        reactivated: reactivatedOpportunities.length,
+                        existingBetweenActorsCount: existingBetweenActors.length,
+                        status: initialStatus,
+                    });
+                    const persistenceOutcome = {
+                        evaluatedCount: state.evaluatedOpportunities.length,
+                        createdCount: createdList.length,
+                        reactivatedCount: reactivatedOpportunities.length,
+                        sameTriggerDuplicateSuppressions: existingBetweenActors.filter((entry) => entry.reason === 'same_trigger_recent_duplicate').length,
+                        pairActiveNegotiationSuppressions: existingBetweenActors.filter((entry) => entry.reason === 'pair_active_negotiation').length,
+                        crossTriggerAllowedCount,
+                        finalAtomicConflictCount: conflicts.length,
+                    };
+                    return {
+                        opportunities: allOpportunities,
+                        existingBetweenActors,
+                        dedupAlreadyAccepted,
+                        persistenceOutcome,
+                        trace: [{
+                                node: "persist",
+                                detail: `Created ${createdList.length}, reactivated ${reactivatedOpportunities.length}, ${existingBetweenActors.length} existing skipped, ${dedupAlreadyAccepted.length} already-accepted pair(s)`,
+                                data: {
+                                    created: createdList.length,
+                                    reactivated: reactivatedOpportunities.length,
+                                    existingSkipped: existingBetweenActors.length,
+                                    alreadyAccepted: dedupAlreadyAccepted.length,
+                                    totalOutput: allOpportunities.length,
+                                    persistenceOutcome,
+                                    durationMs: Date.now() - startTime,
+                                },
+                            }],
+                    };
+                }
+                catch (error) {
+                    const errMsg = error instanceof Error ? error.message : String(error);
+                    persistLog.error('Failed', { error });
+                    return {
+                        opportunities: [],
+                        existingBetweenActors: [],
+                        error: 'Failed to persist opportunities.',
+                        trace: [{
+                                node: "persist_fatal",
+                                detail: `Persist failed: ${errMsg}`,
+                                data: { error: errMsg },
+                            }],
+                    };
+                }
+            });
+        }, (result) => {
+            const r = result;
+            if (r?.error)
+                return `error: ${r.error}`;
+            const opps = r?.opportunities;
+            return opps ? `Persisted ${opps.length} opportunity(ies)` : undefined;
+        });
+        // ═══════════════════════════════════════════════════════════════
+        // CRUD NODES (read, update, delete, send)
+        // ═══════════════════════════════════════════════════════════════
+        /**
+         * Read Node: List opportunities for the user, optionally filtered by networkId.
+         * Fast path — no LLM calls.
+         */
+        const readNode = async (state) => {
+            return timed("OpportunityGraph.read", async () => {
+                readLog.verbose('Listing opportunities', {
+                    userId: state.userId,
+                    networkId: state.networkId,
+                });
+                try {
+                    let indexIdFilter;
+                    if (state.networkId) {
+                        const [isMember, isOwner] = await Promise.all([
+                            this.database.isNetworkMember(state.networkId, state.userId),
+                            this.database.isIndexOwner(state.networkId, state.userId),
+                        ]);
+                        if (!isMember && !isOwner) {
+                            return {
+                                readResult: { count: 0, opportunities: [], message: 'Network not found or you are not a member.' },
+                            };
+                        }
+                        indexIdFilter = state.networkId;
+                    }
+                    const rawList = await this.database.getOpportunitiesForUser(state.userId, {
+                        limit: 30,
+                        ...(indexIdFilter ? { networkId: indexIdFilter } : {}),
+                    });
+                    const list = rawList.filter((opp) => opp.status !== 'expired');
+                    if (list.length === 0) {
+                        return {
+                            readResult: {
+                                count: 0,
+                                message: 'You have no opportunities yet. Use discover_opportunities to search for connections.',
+                                opportunities: [],
+                            },
+                        };
+                    }
+                    // Dedupe by counterpart set (same people = one row) so chat does not show "You and X" per index
+                    const counterpartKey = (opp) => opp.actors
+                        .filter((a) => a.userId !== state.userId && a.role !== 'introducer')
+                        .map((a) => a.userId)
+                        .sort()
+                        .join(',');
+                    const byKey = new Map();
+                    for (const opp of list) {
+                        const key = counterpartKey(opp);
+                        const existing = byKey.get(key);
+                        const conf = Number(opp.interpretation?.confidence ?? opp.confidence ?? 0);
+                        const existingConf = existing ? Number(existing.interpretation?.confidence ?? existing.confidence ?? 0) : 0;
+                        const oppTime = opp.updatedAt instanceof Date ? opp.updatedAt.getTime() : new Date(opp.updatedAt).getTime();
+                        const existingTime = existing
+                            ? (existing.updatedAt instanceof Date ? existing.updatedAt.getTime() : new Date(existing.updatedAt).getTime())
+                            : 0;
+                        if (!existing || conf > existingConf || (conf === existingConf && oppTime > existingTime)) {
+                            byKey.set(key, opp);
+                        }
+                    }
+                    const dedupedList = [...byKey.values()];
+                    const sourceLabel = {
+                        chat: 'Suggested in chat',
+                        opportunity_graph: 'System match',
+                        manual: 'Manual',
+                        cron: 'Scheduled',
+                        member_added: 'Member added',
+                        introducer_discovery: 'Suggested by contact',
+                    };
+                    const enriched = await Promise.all(dedupedList.map(async (opp) => {
+                        // "Other parties" = all actors who are not the current user (exclude introducer for suggestedBy).
+                        // Opportunity graph persists roles as 'agent'|'patient'|'peer'; manual/createManual use 'party'.
+                        const otherParties = opp.actors.filter((a) => a.userId !== state.userId && a.role !== 'introducer');
+                        const introducer = opp.actors.find((a) => a.role === 'introducer');
+                        const partyIds = otherParties.map((a) => a.userId);
+                        const idsToResolve = introducer ? [...partyIds, introducer.userId] : partyIds;
+                        // Use the counterpart's (non-viewer) networkId — it reflects where the match was found.
+                        // actors[0] is typically the viewer with an arbitrary first-target-index value.
+                        const counterpartActor = opp.actors.find((a) => a.userId !== state.userId);
+                        const actorIndexId = counterpartActor?.networkId ?? opp.actors[0]?.networkId;
+                        const [indexRecord, ...profileAndUserPairs] = await Promise.all([
+                            actorIndexId ? this.database.getNetwork(actorIndexId) : Promise.resolve(null),
+                            ...idsToResolve.map(async (uid) => {
+                                const [profile, user] = await Promise.all([
+                                    this.database.getProfile(uid),
+                                    this.database.getUser(uid),
+                                ]);
+                                return (profile?.identity?.name ?? user?.name ?? 'Unknown');
+                            }),
+                        ]);
+                        const connectedWith = profileAndUserPairs.slice(0, partyIds.length);
+                        const suggestedBy = introducer ? profileAndUserPairs[partyIds.length] ?? null : null;
+                        const category = opp.interpretation?.category ?? 'connection';
+                        const confidence = opp.interpretation?.confidence ?? (opp.confidence ? Number(opp.confidence) : null);
+                        const source = opp.detection?.source ? (sourceLabel[opp.detection.source] ?? opp.detection.source) : null;
+                        return {
+                            id: opp.id,
+                            indexName: indexRecord?.title ?? (actorIndexId ?? ''),
+                            connectedWith,
+                            suggestedBy,
+                            reasoning: safeFallbackSummary(opp.interpretation?.reasoning, {
+                                counterpartName: connectedWith.join(' and '),
+                                emptyText: 'Connection opportunity',
+                            }),
+                            status: opp.status,
+                            category,
+                            confidence: confidence != null ? confidence : null,
+                            source,
+                        };
+                    }));
+                    return {
+                        readResult: {
+                            count: enriched.length,
+                            message: `You have ${enriched.length} opportunity(ies).`,
+                            opportunities: enriched,
+                        },
+                    };
+                }
+                catch (err) {
+                    readLog.error('Failed', { error: err });
+                    return {
+                        readResult: { count: 0, opportunities: [], message: 'Failed to list opportunities.' },
+                    };
+                }
+            });
+        };
+        /**
+         * Update Node: Change opportunity status (accept, reject, etc.).
+         * For 'accepted', enforces the self-accept guard: the caller's actor entry
+         * must not already have `actedAt` set — i.e. the caller has not yet been
+         * the one to advance this opportunity's state. Stamps `actedAt` on accept
+         * atomically with the status change via `stampOpportunityActorAction`.
+         */
+        const updateNode = async (state) => {
+            return timed("OpportunityGraph.update", async () => {
+                updateLog.verbose('Updating opportunity status', {
+                    userId: state.userId,
+                    opportunityId: state.opportunityId,
+                    newStatus: state.newStatus,
+                });
+                try {
+                    return {
+                        mutationResult: await updateOpportunityLifecycle(this.database, {
+                            opportunityId: state.opportunityId,
+                            actorUserId: state.userId,
+                            newStatus: state.newStatus,
+                        }),
+                    };
+                }
+                catch (err) {
+                    updateLog.error('Failed', { error: err });
+                    return { mutationResult: { success: false, error: 'Failed to update opportunity.' } };
+                }
+            });
+        };
+        /**
+         * Delete Node: Expire/archive an opportunity.
+         */
+        const deleteNode = async (state) => {
+            return timed("OpportunityGraph.delete", async () => {
+                deleteLog.verbose('Expiring opportunity', {
+                    userId: state.userId,
+                    opportunityId: state.opportunityId,
+                });
+                try {
+                    return {
+                        mutationResult: await deleteOpportunityLifecycle(this.database, {
+                            opportunityId: state.opportunityId,
+                            actorUserId: state.userId,
+                        }),
+                    };
+                }
+                catch (err) {
+                    deleteLog.error('Failed', { error: err });
+                    return { mutationResult: { success: false, error: 'Failed to delete opportunity.' } };
+                }
+            });
+        };
+        /**
+         * Send Node: Promote latent or draft opportunity to pending + queue notification.
+         */
+        const sendNode = async (state) => {
+            return timed("OpportunityGraph.send", async () => {
+                sendLog.verbose('Sending opportunity', {
+                    userId: state.userId,
+                    opportunityId: state.opportunityId,
+                });
+                try {
+                    return {
+                        mutationResult: await sendOpportunityLifecycle(this.database, { opportunityId: state.opportunityId, actorUserId: state.userId }, this.queueNotification),
+                    };
+                }
+                catch (err) {
+                    sendLog.error('Failed', { error: err });
+                    return { mutationResult: { success: false, error: 'Failed to send opportunity.' } };
+                }
+            });
+        };
+        /**
+         * Negotiate Existing Node: Load an existing opportunity by ID and run bilateral negotiation.
+         * Used after introducer approval to trigger the normal negotiation flow for a latent opportunity.
+         */
+        const negotiateExistingNode = async (state) => {
+            if (!state.opportunityId)
+                return {};
+            if (!this.negotiationGraph) {
+                negotiateExistingLog.warn('No negotiationGraph wired; skipping', {
+                    opportunityId: state.opportunityId,
+                });
+                return {};
+            }
+            try {
+                const continuation = state.options.negotiationContinuation;
+                const result = await negotiateExistingOpportunity(this.database, async ({ sourceUser, candidate, indexContextOverrides, continuation: execution }) => {
+                    let receipt;
+                    // Deliberately no `initiatorUserId`: re-entries inherit the prior task's
+                    // stamped seat in negotiation initialization, never re-deriving it here.
+                    const acceptedResults = await negotiateCandidates(this.negotiationGraph, sourceUser, [candidate], { networkId: '', prompt: '' }, {
+                        maxTurns: Number(process.env.NEGOTIATION_MAX_TURNS_AMBIENT) || 6,
+                        indexContextOverrides,
+                        timeoutMs: AMBIENT_PARK_WINDOW_MS,
+                        trigger: 'ambient',
+                        ...(execution ? {
+                            resumeFromTaskId: execution.taskId,
+                            continuationSettlementId: execution.settlementId,
+                            continuationExecution: execution,
+                            onCandidateResolved: async ({ continuationReceipt }) => {
+                                if (continuationReceipt?.successorTaskId === execution.successorTaskId)
+                                    receipt = continuationReceipt;
+                            },
+                        } : {}),
+                    });
+                    return { accepted: acceptedResults.length > 0, ...(receipt ? { receipt } : {}) };
+                }, { opportunityId: state.opportunityId, actorUserId: state.userId, continuation }, this.queueNotification, {
+                    onNotificationFailure: ({ actorId, error }) => {
+                        negotiateExistingLog.warn('Failed to queue notification', { actorId, error });
+                    },
+                });
+                if (result.kind === 'skipped') {
+                    const messages = {
+                        not_found: 'Opportunity not found',
+                        stale_continuation: 'Exact continuation actor binding is stale',
+                        no_source_actor: 'No source actor found',
+                        no_candidate_actor: 'No candidate actor found',
+                    };
+                    negotiateExistingLog.warn(messages[result.reason], {
+                        opportunityId: state.opportunityId,
+                        ...(result.reason === 'stale_continuation' && continuation ? { taskId: continuation.taskId } : {}),
+                    });
+                    return {};
+                }
+                negotiateExistingLog.info('Negotiation complete', {
+                    opportunityId: result.opportunityId,
+                    accepted: result.accepted,
+                    continuationFence: result.continuationFence,
+                });
+                return result.receipt ? { negotiationContinuationReceipt: result.receipt } : {};
+            }
+            catch (err) {
+                negotiateExistingLog.error('Failed', { opportunityId: state.opportunityId, error: err });
+                return { error: `Failed to load opportunity: ${err instanceof Error ? err.message : String(err)}` };
+            }
+            return {};
+        };
+        /**
+         * Node: Approve Introduction
+         * Called by the introducer to approve a latent introducer-pattern opportunity.
+         * Sets approved=true on the introducer actor (status stays latent), then
+         * enqueues a negotiate_existing job so the parties negotiate normally.
+         */
+        const approveIntroductionNode = async (state) => {
+            return {
+                mutationResult: await approveOpportunityIntroduction(this.database, { opportunityId: state.opportunityId, actorUserId: state.userId }, this.queueNegotiateExisting),
+            };
+        };
+        // ═══════════════════════════════════════════════════════════════
+        // CONDITIONAL ROUTING FUNCTIONS
+        // ═══════════════════════════════════════════════════════════════
+        /**
+         * Router: Decides which path based on operationMode.
+         */
+        const routeByMode = (state) => {
+            const mode = state.operationMode ?? 'create';
+            if (mode === 'read')
+                return 'read';
+            if (mode === 'update')
+                return 'update';
+            if (mode === 'delete')
+                return 'delete_opp';
+            if (mode === 'send')
+                return 'send';
+            if (mode === 'create_introduction')
+                return 'intro_validation';
+            if (mode === 'negotiate_existing')
+                return 'negotiate_existing';
+            if (mode === 'approve_introduction')
+                return 'approve_introduction';
+            // 'create' is the default discovery pipeline
+            return 'prep';
+        };
+        /**
+         * After prep: check if user has indexed intents.
+         * Early exit if none (cannot find opportunities).
+         */
+        const shouldContinueAfterPrep = (state) => {
+            if (state.error) {
+                routingLog.verbose('Error in prep - ending early');
+                return END;
+            }
+            // Continuation mode: skip scope/resolve/discovery, go straight to evaluation
+            if (state.operationMode === 'continue_discovery') {
+                routingLog.verbose('Continue discovery → skipping to evaluation', {
+                    candidatesLoaded: state.candidates.length,
+                });
+                return 'evaluation';
+            }
+            routingLog.verbose('Continuing to scope');
+            return 'scope';
+        };
+        /**
+         * After scope: check if we have target indexes.
+         */
+        const shouldContinueAfterScope = (state) => {
+            if (state.error || state.targetNetworks.length === 0) {
+                routingLog.verbose('No target indexes - ending early');
+                return END;
+            }
+            routingLog.verbose('Continuing to resolve');
+            return 'resolve';
+        };
+        /**
+         * After discovery: if create-intent signal was set, end so tool can return it; else continue to evaluation.
+         */
+        const shouldContinueAfterDiscovery = (state) => {
+            if (state.createIntentSuggested) {
+                routingLog.verbose('Create-intent suggested - ending for tool signal');
+                return END;
+            }
+            return 'evaluation';
+        };
+        /**
+         * After intro_validation: if validation set state.error, end early; else continue to intro_evaluation.
+         */
+        const routeAfterIntroValidation = (state) => {
+            if (state.error) {
+                routingLog.verbose('Intro validation error - ending early');
+                return END;
+            }
+            return 'intro_evaluation';
+        };
+        // ═══════════════════════════════════════════════════════════════
+        // GRAPH ASSEMBLY
+        // ═══════════════════════════════════════════════════════════════
+        const workflow = new StateGraph(OpportunityGraphState)
+            // Add all nodes
+            .addNode('prep', prepNode)
+            .addNode('scope', scopeNode)
+            .addNode('resolve', resolveNode)
+            .addNode('discovery', discoveryNode)
+            .addNode('evaluation', evaluationNode)
+            .addNode('ranking', rankingNode)
+            .addNode('intro_validation', introValidationNode)
+            .addNode('intro_evaluation', introEvaluationNode)
+            .addNode('persist', persistNode)
+            // CRUD nodes
+            .addNode('read', readNode)
+            .addNode('update', updateNode)
+            .addNode('delete_opp', deleteNode)
+            .addNode('send', sendNode)
+            .addNode('negotiate_existing', negotiateExistingNode)
+            .addNode('approve_introduction', approveIntroductionNode)
+            // Route by operation mode from START
+            .addConditionalEdges(START, routeByMode, {
+            prep: 'prep',
+            intro_validation: 'intro_validation',
+            read: 'read',
+            update: 'update',
+            delete_opp: 'delete_opp',
+            send: 'send',
+            negotiate_existing: 'negotiate_existing',
+            approve_introduction: 'approve_introduction',
+        })
+            // Introduction path: validation -> evaluation -> persist (or END on validation error)
+            .addConditionalEdges('intro_validation', routeAfterIntroValidation, {
+            intro_evaluation: 'intro_evaluation',
+            [END]: END,
+        })
+            .addEdge('intro_evaluation', 'persist')
+            // CRUD fast paths -> END
+            .addEdge('read', END)
+            .addEdge('update', END)
+            .addEdge('delete_opp', END)
+            .addEdge('send', END)
+            .addEdge('negotiate_existing', END)
+            .addEdge('approve_introduction', END)
+            // Conditional routing: early exit if no indexed intents
+            .addConditionalEdges('prep', shouldContinueAfterPrep, {
+            scope: 'scope',
+            evaluation: 'evaluation',
+            [END]: END,
+        })
+            // Conditional routing: early exit if no target indexes
+            .addConditionalEdges('scope', shouldContinueAfterScope, {
+            resolve: 'resolve',
+            [END]: END,
+        })
+            .addEdge('resolve', 'discovery')
+            .addConditionalEdges('discovery', shouldContinueAfterDiscovery, {
+            evaluation: 'evaluation',
+            [END]: END,
+        })
+            // Discovery → Ranking → Persist → Negotiate (post-persist).
+            // Fresh and continuation discovery both negotiate newly created/reactivated
+            // opportunities. The stage is skipped only when no negotiation graph is wired or
+            // persistence produced no negotiation targets (negotiateNode also guards both cases).
+            .addNode('negotiate', negotiateNode)
+            .addEdge('evaluation', 'ranking')
+            .addEdge('ranking', 'persist')
+            .addConditionalEdges('persist', (state) => {
+            if (!this.negotiationGraph)
+                return END;
+            if (!state.opportunities || state.opportunities.length === 0)
+                return END;
+            return 'negotiate';
+        }, {
+            negotiate: 'negotiate',
+            [END]: END,
+        })
+            .addEdge('negotiate', END);
+        return workflow.compile();
+    }
+}