@indexnetwork/protocol 14.3.2-rc.477.1 → 16.1.1-rc.478.1

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

@@ -0,0 +1,538 @@
+/**
+ * The opportunity operations that are not discovery.
+ *
+ * These used to be graph nodes reached through an `operationMode` conditional
+ * edge at START — nine one-node paths sharing a state machine they never used.
+ * They are plain async functions now; callers invoke the one they mean. Only
+ * the discovery pipeline still needs a graph.
+ *
+ * Each returns the same shape the corresponding node returned, so callers read
+ * `readResult` / `mutationResult` exactly as before.
+ */
+import { timed } from '../../shared/observability/performance.js';
+import { requestContext } from '../../shared/observability/request-context.js';
+import { getAbortSignalConfig } from '../../shared/agent/model-signal.js';
+import { safeFallbackSummary } from './opportunity.presentation.js';
+import { AMBIENT_PARK_WINDOW_MS, negotiateCandidates } from '../../negotiations/index.js';
+import { approveOpportunityIntroduction, deleteOpportunityLifecycle, sendOpportunityLifecycle, updateOpportunityLifecycle } from './opportunity.lifecycle.js';
+import { negotiateExistingOpportunity } from './opportunity.existing-negotiation.js';
+import { buildNetworkContexts, deleteLog, introEvaluationLog, introValidationLog, negotiateExistingLog, readLog, sendLog, updateLog } from './opportunity.graph.shared.js';
+import { persistNode } from './opportunity.graph.persist-node.js';
+/**
+ * Read mode: list opportunities for the user, optionally filtered by networkId.
+ * Fast path — no LLM calls.
+ */
+export async function readOpportunities(deps, request) {
+    return timed("OpportunityGraph.read", async () => {
+        readLog.verbose('Listing opportunities', {
+            userId: request.userId,
+            networkId: request.networkId,
+        });
+        try {
+            let indexIdFilter;
+            if (request.networkId) {
+                const [isMember, isOwner] = await Promise.all([
+                    deps.database.isNetworkMember(request.networkId, request.userId),
+                    deps.database.isIndexOwner(request.networkId, request.userId),
+                ]);
+                if (!isMember && !isOwner) {
+                    return {
+                        readResult: { count: 0, opportunities: [], message: 'Network not found or you are not a member.' },
+                    };
+                }
+                indexIdFilter = request.networkId;
+            }
+            const rawList = await deps.database.getOpportunitiesForUser(request.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. Create or refine an approved signal; matching runs in the background. Use list_opportunities later to review persisted results.',
+                        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 !== request.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 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 !== request.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 !== request.userId);
+                const actorIndexId = counterpartActor?.networkId ?? opp.actors[0]?.networkId;
+                const [indexRecord, ...profileAndUserPairs] = await Promise.all([
+                    actorIndexId ? deps.database.getNetwork(actorIndexId) : Promise.resolve(null),
+                    ...idsToResolve.map(async (uid) => {
+                        const [profile, user] = await Promise.all([
+                            deps.database.getProfile(uid),
+                            deps.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 ? (OPPORTUNITY_SOURCE_LABEL[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.' },
+            };
+        }
+    });
+}
+/** Human-readable label per detection source, for the read-mode listing. */
+const OPPORTUNITY_SOURCE_LABEL = {
+    chat: 'Suggested in chat',
+    opportunity_graph: 'System match',
+    manual: 'Manual',
+    cron: 'Scheduled',
+    member_added: 'Member added',
+    introducer_discovery: 'Suggested by contact',
+};
+/**
+ * Update mode: 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`.
+ */
+export async function updateOpportunityStatus(deps, request) {
+    return timed("OpportunityGraph.update", async () => {
+        updateLog.verbose('Updating opportunity status', {
+            userId: request.userId,
+            opportunityId: request.opportunityId,
+            newStatus: request.newStatus,
+        });
+        try {
+            return {
+                mutationResult: await updateOpportunityLifecycle(deps.database, {
+                    opportunityId: request.opportunityId,
+                    actorUserId: request.userId,
+                    newStatus: request.newStatus,
+                }),
+            };
+        }
+        catch (err) {
+            updateLog.error('Failed', { error: err });
+            return { mutationResult: { success: false, error: 'Failed to update opportunity.' } };
+        }
+    });
+}
+/** Delete mode: expire/archive an opportunity. */
+export async function deleteOpportunity(deps, request) {
+    return timed("OpportunityGraph.delete", async () => {
+        deleteLog.verbose('Expiring opportunity', {
+            userId: request.userId,
+            opportunityId: request.opportunityId,
+        });
+        try {
+            return {
+                mutationResult: await deleteOpportunityLifecycle(deps.database, {
+                    opportunityId: request.opportunityId,
+                    actorUserId: request.userId,
+                }),
+            };
+        }
+        catch (err) {
+            deleteLog.error('Failed', { error: err });
+            return { mutationResult: { success: false, error: 'Failed to delete opportunity.' } };
+        }
+    });
+}
+/** Send mode: promote a latent or draft opportunity to pending + queue notification. */
+export async function sendOpportunity(deps, request) {
+    return timed("OpportunityGraph.send", async () => {
+        sendLog.verbose('Sending opportunity', {
+            userId: request.userId,
+            opportunityId: request.opportunityId,
+        });
+        try {
+            return {
+                mutationResult: await sendOpportunityLifecycle(deps.database, { opportunityId: request.opportunityId, actorUserId: request.userId }, deps.queueNotification),
+            };
+        }
+        catch (err) {
+            sendLog.error('Failed', { error: err });
+            return { mutationResult: { success: false, error: 'Failed to send opportunity.' } };
+        }
+    });
+}
+/**
+ * Approve-introduction mode.
+ * 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.
+ */
+export async function approveIntroduction(deps, request) {
+    return {
+        mutationResult: await approveOpportunityIntroduction(deps.database, { opportunityId: request.opportunityId, actorUserId: request.userId }, deps.queueNegotiateExisting),
+    };
+}
+/**
+ * Negotiate-existing mode: load an existing opportunity by ID and run bilateral negotiation.
+ * Used after introducer approval to trigger the normal negotiation flow for a latent opportunity.
+ */
+export async function negotiateExisting(deps, request) {
+    if (!request.opportunityId)
+        return {};
+    if (!deps.negotiationGraph) {
+        negotiateExistingLog.warn('No negotiationGraph wired; skipping', {
+            opportunityId: request.opportunityId,
+        });
+        return {};
+    }
+    try {
+        const continuation = request.continuation;
+        const result = await negotiateExistingOpportunity(deps.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(deps.negotiationGraph, sourceUser, [candidate], { networkId: '', prompt: '' }, {
+                maxTurns: Number(process.env.NEGOTIATION_MAX_TURNS_AMBIENT) || 6,
+                indexContextOverrides,
+                timeoutMs: AMBIENT_PARK_WINDOW_MS,
+                ...(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: request.opportunityId, actorUserId: request.userId, continuation }, deps.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: request.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: request.opportunityId, error: err });
+        return { error: `Failed to load opportunity: ${err instanceof Error ? err.message : String(err)}` };
+    }
+}
+/**
+ * Introduction mode: validate → evaluate → persist.
+ *
+ * Validation gates on scope and membership; evaluation asks the evaluator to
+ * justify the pairing (falling back to the introducer's own word); persistence
+ * reuses the discovery pipeline's persist stage.
+ */
+export async function createIntroduction(deps, request) {
+    const state = introductionState(request);
+    const validation = await validateIntroduction(deps, state);
+    // Mirrors what the graph produced on this path: the error, and empty results.
+    if (validation.error)
+        return { opportunities: [], evaluatedOpportunities: [], agentTimings: [], ...validation };
+    const evaluation = await evaluateIntroduction(deps, { ...state, ...validation });
+    const persisted = await persistNode({ ...state, ...evaluation }, deps);
+    return { ...evaluation, ...persisted };
+}
+/**
+ * Introduction validation: network scope, membership for introducer and all
+ * party users, and no existing opportunity between the parties.
+ */
+export async function validateIntroduction(deps, 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([
+                deps.database.isNetworkMember(primaryNetworkId, state.userId),
+                deps.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([
+                    deps.database.isNetworkMember(primaryNetworkId, userId),
+                    deps.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 deps.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 the 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 };
+}
+/**
+ * Introduction evaluation: runs the entity-bundle evaluator and sets
+ * evaluatedOpportunities (one) + introductionContext.
+ */
+export async function evaluateIntroduction(deps, 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 deps.database.getUser(state.userId);
+            introducerName = introducerUser?.name ?? undefined;
+            const networkContexts = await buildNetworkContexts(entities, deps.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 deps.evaluatorAgent.invokeEntityBundle(input, { minScore: 0, ...getAbortSignalConfig() });
+            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,
+        };
+    });
+}
+/**
+ * The channel defaults the introduction path relies on. Discovery-only channels
+ * stay at their empty values because the introduction path never fills them.
+ */
+function introductionState(request) {
+    return {
+        userId: request.userId,
+        searchQuery: undefined,
+        networkId: request.networkId,
+        indexScope: undefined,
+        triggerIntentId: undefined,
+        targetUserId: undefined,
+        onBehalfOfUserId: undefined,
+        options: { ...(request.options ?? {}) },
+        operationMode: 'create_introduction',
+        introductionEntities: request.introductionEntities,
+        introductionHint: request.introductionHint,
+        requiredNetworkId: request.requiredNetworkId,
+        introductionContext: undefined,
+        opportunityId: undefined,
+        newStatus: undefined,
+        indexedIntents: [],
+        userNetworks: [],
+        targetNetworks: [],
+        indexRelevancyScores: {},
+        discoverySource: 'context',
+        resolvedTriggerIntentId: undefined,
+        sourceProfile: null,
+        sourcePremises: [],
+        sourceContexts: [],
+        resolvedIntentInIndex: false,
+        createIntentSuggested: false,
+        suggestedIntentDescription: undefined,
+        hydeEmbeddings: {},
+        candidates: [],
+        remainingCandidates: [],
+        discoveryId: null,
+        evaluatedCandidates: [],
+        evaluatedOpportunities: [],
+        opportunities: [],
+        existingBetweenActors: [],
+        persistenceOutcome: undefined,
+        negotiationContinuationReceipt: undefined,
+        error: undefined,
+        readResult: undefined,
+        mutationResult: undefined,
+        trace: [],
+        agentTimings: [],
+        discoveryNegotiations: [],
+        discoverySummary: null,
+    };
+}

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

@@ -0,0 +1,109 @@
+/**
+ * Discovery pipeline, stage 7: post-persist negotiation.
+ *
+ * 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.
+ */
+import { type OpportunityGraphDeps, type OpportunityState } from './opportunity.graph.shared.js';
+/**
+ * Node 3b: Negotiate (post-persist)
+ */
+export declare function negotiateNode(state: OpportunityState, deps: OpportunityGraphDeps): Promise<{
+    trace?: undefined;
+    discoveryNegotiations?: undefined;
+    discoverySummary?: undefined;
+} | {
+    trace: {
+        node: string;
+        detail: string;
+        data: {
+            negotiateTimeoutMs: number;
+            candidateCount: number;
+            durationMs: number;
+        };
+    }[];
+    discoveryNegotiations: {
+        indexContext: string;
+        outcome: {
+            reasoning: string;
+            hasOpportunity: boolean;
+            reason?: "timeout" | "turn_cap" | "screened_out" | undefined;
+            agreedRoles?: {
+                userId: string;
+                role: "agent" | "patient" | "peer";
+            }[] | undefined;
+        };
+        counterpartyHint: string;
+        counterpartyId: string;
+        turns: {
+            reasoning: string;
+            action: "propose" | "accept" | "reject" | "counter" | "question" | "outreach" | "withdraw" | "decline" | "ask_user";
+            suggestedRoles: {
+                ownUser: "agent" | "patient" | "peer";
+                otherUser: "agent" | "patient" | "peer";
+            };
+        }[];
+        seedAssessmentScore?: number | undefined;
+    }[];
+    discoverySummary: import("../../shared/schemas/discovery-question.schema.js").DiscoverySummary;
+} | {
+    trace: ({
+        node: string;
+        detail: string;
+        data: {
+            userId: string;
+            opportunityId: string | undefined;
+            name: string;
+            outcome: string;
+            turns: number;
+        };
+    } | {
+        node: string;
+        detail: string;
+        data: {
+            durationMs: number;
+            candidateCount: number;
+            acceptedCount: number;
+            otherCount: number;
+        };
+    })[];
+    discoveryNegotiations: {
+        indexContext: string;
+        outcome: {
+            reasoning: string;
+            hasOpportunity: boolean;
+            reason?: "timeout" | "turn_cap" | "screened_out" | undefined;
+            agreedRoles?: {
+                userId: string;
+                role: "agent" | "patient" | "peer";
+            }[] | undefined;
+        };
+        counterpartyHint: string;
+        counterpartyId: string;
+        turns: {
+            reasoning: string;
+            action: "propose" | "accept" | "reject" | "counter" | "question" | "outreach" | "withdraw" | "decline" | "ask_user";
+            suggestedRoles: {
+                ownUser: "agent" | "patient" | "peer";
+                otherUser: "agent" | "patient" | "peer";
+            };
+        }[];
+        seedAssessmentScore?: number | undefined;
+    }[];
+    discoverySummary: import("../../shared/schemas/discovery-question.schema.js").DiscoverySummary;
+} | {
+    trace: {
+        node: string;
+        detail: string;
+        data: {
+            durationMs: number;
+            error: boolean;
+        };
+    }[];
+    discoveryNegotiations: never[];
+    discoverySummary: import("../../shared/schemas/discovery-question.schema.js").DiscoverySummary;
+}>;