@indexnetwork/protocol 6.2.1-rc.378.1 → 6.2.3-rc.380.1

package/dist/opportunity/opportunity.graph.js

@@ -25,6 +25,7 @@ import { hasUnsupportedOpportunityClaim } from './opportunity.claim-safety.js';
 import { persistOpportunities } from './opportunity.persist.js';
 import { INTRODUCER_DISCOVERY_SOURCE } from './opportunity.introducer.js';
 import { negotiateCandidates } from "../negotiation/negotiation.graph.js";
+import { ASK_USER_LOCK_SLACK_MS, askUserAnswerWindowMs } from "../negotiation/negotiation.protocol.js";
 import { AMBIENT_PARK_WINDOW_MS } from "../negotiation/negotiation.tools.js";
 import { buildDiscoverySummary, toDiscoveryNegotiation } from "./negotiation-summary.builder.js";
 import { protocolLogger, withCallLogging } from '../shared/observability/protocol.logger.js';
@@ -32,6 +33,7 @@ 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 './opportunity.evidence.js';
+import { normalizeOpportunityActorIntent, resolveOpportunityActorIntent } from './opportunity.actor.js';
 const logger = protocolLogger('OpportunityGraph');
 const prepLog = protocolLogger('OpportunityGraph:Prep');
 const scopeLog = protocolLogger('OpportunityGraph:Scope');
@@ -54,6 +56,21 @@ 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 NEGOTIATION_INTENT_LIMIT = 5;
+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;
+}
 /** Put an opportunity actor's exact intent first, then fill the bounded context without duplicates. */
 export function buildPrioritizedNegotiationIntents(activeIntents, exactIntentId, fallbackIntent) {
     const exactId = typeof exactIntentId === 'string' && exactIntentId.trim().length > 0
@@ -1827,6 +1844,27 @@ export class OpportunityGraphFactory {
                 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
@@ -1859,6 +1897,7 @@ export class OpportunityGraphFactory {
                     opportunityCount: state.opportunities.length,
                     discoveryUserId,
                 });
+                const filteredBeforeInvocation = [];
                 const candidateEntries = state.opportunities
                     .map(opp => {
                     // Skip opportunities where any introducer exists but has not yet approved.
@@ -1870,6 +1909,7 @@ export class OpportunityGraphFactory {
                             introducerCount: introducerActors.length,
                             approvedCount: introducerActors.filter(a => a.approved === true).length,
                         });
+                        filteredBeforeInvocation.push(opp.id);
                         return null;
                     }
                     const candidateActor = opp.actors.find(a => a.userId !== discoveryUserId);
@@ -1879,18 +1919,20 @@ export class OpportunityGraphFactory {
                             discoveryUserId,
                             actors: opp.actors?.map(a => ({ userId: a.userId, role: a.role })) ?? [],
                         });
+                        filteredBeforeInvocation.push(opp.id);
                         return null;
                     }
                     return { opp, 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, candidateActor }) => {
                     const userId = candidateActor.userId;
-                    const candidateIntentId = candidateActor.intentId ?? candidateActor.intent;
+                    const candidateIntentId = resolveOpportunityActorIntent(candidateActor);
                     const [profile, user, activeIntents, intent] = await Promise.all([
                         this.database.getProfile(userId).catch(() => null),
                         this.database.getUser(userId).catch(() => null),
@@ -1904,6 +1946,7 @@ export class OpportunityGraphFactory {
                     return {
                         userId,
                         opportunityId: opp.id,
+                        opportunityUpdatedAt: opp.updatedAt,
                         reasoning: opp.interpretation?.reasoning ?? '',
                         valencyRole: candidateActor.role ?? 'peer',
                         networkId: candidateActor.networkId,
@@ -1991,7 +2034,10 @@ export class OpportunityGraphFactory {
                 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,
@@ -2007,6 +2053,9 @@ export class OpportunityGraphFactory {
                         turns,
                         outcome,
                     });
+                    if (candidate.opportunityId) {
+                        await compensateTasklessNegotiatingOpportunity(candidate.opportunityId);
+                    }
                     if (state.trigger !== 'orchestrator')
                         return;
                     // ─── orchestrator streaming body ───
@@ -2098,6 +2147,12 @@ export class OpportunityGraphFactory {
                             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 });
@@ -2182,6 +2237,7 @@ export class OpportunityGraphFactory {
                 };
             }
             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 {
@@ -2507,7 +2563,7 @@ export class OpportunityGraphFactory {
                     }
                     if (evaluatedToPersist.length === 0)
                         return { opportunities: [] };
-                    const updateStatusIfStillEligible = async (opportunityId, status, existingActors) => {
+                    const updateStatusIfStillEligible = async (opportunityId, status, existingActors, expectedStatus) => {
                         // Reactivation preserves the existing opportunity row, so lock the
                         // existing participant anchors rather than the evaluator's current
                         // (often network-less) actor output. Introducers do not participate
@@ -2520,7 +2576,7 @@ export class OpportunityGraphFactory {
                             persistLog.error('Network-eligible status update adapter is unavailable; failing closed');
                             return null;
                         }
-                        return this.database.updateOpportunityStatusIfNetworkEligible(opportunityId, status, anchors, networkEligibility);
+                        return this.database.updateOpportunityStatusIfNetworkEligible(opportunityId, status, anchors, networkEligibility, expectedStatus);
                     };
                     const itemsToPersist = [];
                     const reactivatedOpportunities = [];
@@ -2588,12 +2644,15 @@ export class OpportunityGraphFactory {
                                 continue;
                             }
                             // Introduction path: manual detection, introducer actor, curator_judgment signal.
-                            const evaluatorActors = evaluated.actors.map((a) => ({
-                                networkId: a.networkId ?? indexIdForActors,
-                                userId: a.userId,
-                                role: a.role,
-                                ...(a.intentId ? { intent: a.intentId } : {}),
-                            }));
+                            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
@@ -2638,12 +2697,15 @@ export class OpportunityGraphFactory {
                                 continue;
                             }
                             // Introducer discovery path: introducer is state.userId, target is onBehalfOfUserId.
-                            const evaluatorActors = evaluated.actors.map((a) => ({
-                                networkId: a.networkId ?? indexIdForActors,
-                                userId: a.userId,
-                                role: a.role,
-                                ...(a.intentId ? { intent: a.intentId } : {}),
-                            }));
+                            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
@@ -2668,7 +2730,7 @@ export class OpportunityGraphFactory {
                                     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);
+                                        const reactivated = await updateStatusIfStillEligible(existing.id, 'draft', existing.actors, existing.status);
                                         if (reactivated) {
                                             persistLog.verbose('Reactivated opportunity (introduction path)', {
                                                 opportunityId: existing.id,
@@ -2683,25 +2745,21 @@ export class OpportunityGraphFactory {
                                 else if (existing.status === 'negotiating') {
                                     // Orphan heal (introduction path): same logic as discovery path
                                     const priorTask = await this.database.getNegotiationTaskForOpportunity(existing.id);
-                                    if (priorTask) {
-                                        const activeStates = ['submitted', 'working', 'input_required', 'waiting_for_agent', 'claimed'];
-                                        const isFresh = (Date.now() - new Date(priorTask.updatedAt).getTime()) < 5 * 60 * 1000;
-                                        if (activeStates.includes(priorTask.state) && isFresh) {
-                                            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;
-                                        }
+                                    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);
+                                    const reactivated = await updateStatusIfStillEligible(existing.id, 'draft', existing.actors, existing.status);
                                     if (reactivated) {
                                         persistLog.info('Resuming orphaned negotiating opportunity (introduction path)', {
                                             opportunityId: existing.id,
@@ -2714,7 +2772,7 @@ export class OpportunityGraphFactory {
                                 }
                                 else if (existing.status === 'latent') {
                                     // Upgrade latent to draft for introduction path
-                                    const upgraded = await updateStatusIfStillEligible(existing.id, 'draft', existing.actors);
+                                    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,
@@ -2785,13 +2843,16 @@ export class OpportunityGraphFactory {
                                     }
                                 }
                             }
-                            const evaluatorActors = evaluated.actors.map((a) => ({
-                                networkId: a.networkId ?? indexIdForActors,
-                                userId: a.userId,
-                                role: a.role,
-                                ...(a.intentId ? { intent: a.intentId } : {}),
-                                ...(premiseLookup.has(a.userId) ? { premise: premiseLookup.get(a.userId).premiseId } : {}),
-                            }));
+                            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) {
@@ -2830,7 +2891,7 @@ export class OpportunityGraphFactory {
                                     // 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);
+                                    const reactivated = await updateStatusIfStillEligible(existing.id, initialStatus, existing.actors, existing.status);
                                     if (reactivated) {
                                         persistLog.verbose('Reactivated opportunity', {
                                             opportunityId: existing.id,
@@ -2846,27 +2907,23 @@ export class OpportunityGraphFactory {
                                     // 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) {
-                                        const activeStates = ['submitted', 'working', 'input_required', 'waiting_for_agent', 'claimed'];
-                                        const isFresh = (Date.now() - new Date(priorTask.updatedAt).getTime()) < 5 * 60 * 1000;
-                                        if (activeStates.includes(priorTask.state) && isFresh) {
-                                            // 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;
-                                        }
+                                    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);
+                                    const reactivated = await updateStatusIfStillEligible(existing.id, initialStatus, existing.actors, existing.status);
                                     if (reactivated) {
                                         persistLog.info('Resuming orphaned negotiating opportunity', {
                                             opportunityId: existing.id,
@@ -2879,7 +2936,7 @@ export class OpportunityGraphFactory {
                                 }
                                 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);
+                                    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,
@@ -3412,8 +3469,8 @@ export class OpportunityGraphFactory {
                     negotiateExistingLog.warn('No candidate actor found', { opportunityId: state.opportunityId });
                     return {};
                 }
-                const sourceIntentId = sourceActor.intentId ?? sourceActor.intent;
-                const candidateIntentId = candidateActor.intentId ?? candidateActor.intent;
+                const sourceIntentId = resolveOpportunityActorIntent(sourceActor);
+                const candidateIntentId = resolveOpportunityActorIntent(candidateActor);
                 // Load user data for both actors in parallel
                 const [sourceUserAccount, sourceProfile, sourceIntents, candidateAccount, candidateProfile, candidateIntents] = await Promise.all([
                     this.database.getUser(sourceActor.userId).catch(() => null),
@@ -3673,16 +3730,13 @@ export class OpportunityGraphFactory {
             [END]: END,
         })
             // Discovery → Ranking → Persist → Negotiate (post-persist).
-            // Negotiation runs against persisted opportunities so each negotiation receives the
-            // opportunity's id and its outcome flips status (pending|stalled|rejected) via the
-            // negotiation graph's finalize node. Skipped for continue_discovery and when no
-            // negotiation graph or no opportunities were persisted (negotiateNode returns early).
+            // 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 (state.operationMode === 'continue_discovery')
-                return END;
             if (!this.negotiationGraph)
                 return END;
             if (!state.opportunities || state.opportunities.length === 0)