@indexnetwork/protocol 22.0.0-rc.499.1 → 64.0.0

package/dist/{opportunities → internal/opportunities}/radar/radar.graph.js

@@ -2,7 +2,7 @@
  * Radar Graph: Build the opportunity radar view — a flat, presenter-texted
  * list of opportunity cards for a viewer, optionally scoped to one intent.
  *
- * Independent of ChatGraph. Flow:
+ * Flow:
  * loadOpportunities → checkPresenterCache → [generateCardText if misses]
  * → cachePresenterResults → normalizeItems
  *
@@ -21,24 +21,19 @@ import { buildRadarCardPresentationCacheKey } from '../opportunity.presentation.
 import { protocolLogger } from '../../shared/observability/protocol.logger.js';
 import { timed } from '../../shared/observability/performance.js';
 import { requestContext } from "../../shared/observability/request-context.js";
-import { adjustedConfidence, latestPoolDemotionDetail, readActivePoolAdjustments } from '../discriminator/discriminator.adjustments.js';
-import { poolQuestionsRanking } from '../discriminator/discriminator.env.js';
 const logger = protocolLogger('RadarGraph');
 const checkPresenterCacheLog = protocolLogger('RadarGraph:checkPresenterCache');
 const cachePresenterResultsLog = protocolLogger('RadarGraph:cachePresenterResults');
 const generateCardTextLog = protocolLogger('RadarGraph:generateCardText');
 const normalizeItemsLog = protocolLogger('RadarGraph:normalizeItems');
 /** Default radar statuses: the lifecycle stages a viewer can act on today. */
-export const DEFAULT_RADAR_STATUSES = ['latent', 'pending'];
+export const DEFAULT_RADAR_STATUSES = ['pending'];
 // Exhaustive registry — keys must cover every OpportunityStatus union member.
 // Adding a new status to OpportunityStatus without adding a key here is a TS error,
 // which is the whole point: prevents ALL_OPPORTUNITY_STATUSES from silently drifting.
 const OPPORTUNITY_STATUS_REGISTRY = {
-    latent: true,
-    draft: true,
     negotiating: true,
     pending: true,
-    stalled: true,
     accepted: true,
     rejected: true,
     expired: true,
@@ -116,39 +111,18 @@ const getRawConfidence = (opp) => {
     }
     return 0;
 };
-/**
- * Sort confidence, optionally pool-adjusted (IND-419): when
- * POOL_QUESTIONS_RANKING=on, answered discriminators multiply confidence by
- * their stored factors (floor 0.3) so the user's answers re-rank the radar.
- * Flag off → identical to raw confidence (adjustments are write-only).
- */
-const getPoolRankingProvenance = (state) => {
-    if (poolQuestionsRanking() !== 'on' ||
-        !state.userId ||
-        state.scopeType !== 'intent' ||
-        !state.scopeId)
-        return null;
-    return { recipientUserId: state.userId, intentId: state.scopeId };
-};
-const hasPoolAdjustment = (opp, provenance) => readActivePoolAdjustments(opp.metadata, provenance).length > 0;
-const getConfidence = (opp, provenance) => {
-    const raw = getRawConfidence(opp);
-    if (!provenance)
-        return raw;
-    return adjustedConfidence(raw, opp.metadata, provenance);
-};
-/** Unique non-introducer, non-viewer userIds for an opportunity (actors can repeat). */
+/** Unique non-viewer userIds for an opportunity (actors can repeat). */
 const getUniqueCounterpartUserIds = (opp, viewerId) => {
     const ids = new Set();
     for (const a of opp.actors) {
-        if (a.role !== 'introducer' && a.userId !== viewerId && a.userId) {
+        if (a.userId !== viewerId && a.userId) {
             ids.add(a.userId);
         }
     }
     return ids;
 };
 const pickDisplayCounterpartActor = (opportunity, viewerId) => {
-    const candidates = opportunity.actors.filter((actor) => actor.userId !== viewerId && actor.role !== 'introducer');
+    const candidates = opportunity.actors.filter((actor) => actor.userId !== viewerId);
     if (candidates.length === 0) {
         return null;
     }
@@ -199,11 +173,10 @@ export async function loadOpportunitiesNode(state, deps) {
         }
         try {
             // Minimum of 50 ensures enough candidates across all radar categories
-            // (connection, connector-flow, expired) for selectByComposition to fill
+            // (connection, expired) for selectByComposition to fill
             // its soft targets, even after visibility filtering and dedup.
             const fetchLimit = Math.min(150, Math.max(50, state.limit * 3));
             const statuses = state.statuses ?? DEFAULT_RADAR_STATUSES;
-            const poolRankingProvenance = getPoolRankingProvenance(state);
             const options = {
                 limit: fetchLimit,
                 statuses,
@@ -220,7 +193,7 @@ export async function loadOpportunitiesNode(state, deps) {
             // Actionability only gates the live statuses a viewer could act on:
             // latent/pending cards the viewer cannot act on are noise, but
             // terminal/internal statuses (accepted, rejected, expired, negotiating,
-            // stalled, draft) are deliberate history — when a caller explicitly
+            // draft) are deliberate history — when a caller explicitly
             // requests them via `statuses`, they must pass through (they are never
             // actionable by rule 5, so filtering them here would return nothing).
             // The requested-status membership check is defense-in-depth: rows
@@ -229,18 +202,18 @@ export async function loadOpportunitiesNode(state, deps) {
             const visibleForRadar = visible.filter((opp) => {
                 if (!requestedStatuses.has(opp.status))
                     return false;
-                if (opp.status === 'latent' || opp.status === 'pending') {
-                    return isActionableForViewer(opp.actors, opp.status, state.userId);
+                if (opp.status === 'pending') {
+                    return isActionableForViewer(opp.actors, opp.status, state.userId, opp.committedActorIds ?? []);
                 }
                 return true;
             });
             const explicitStatuses = (state.statuses?.length ?? 0) > 0;
             if (explicitStatuses) {
-                // Lifecycle view (e.g. intent radar): newest-first so counterpart
-                // dedup keeps each person's most recent state (an accepted
-                // opportunity supersedes an older pending one), no composition
-                // capping — the caller wants the full pipeline up to `limit`.
-                const newestFirst = [...visibleForRadar].sort((a, b) => safeParseDate(b.updatedAt) - safeParseDate(a.updatedAt));
+                // Lifecycle view (e.g. intent radar): newest-created first so status
+                // transitions do not reorder cards merely by touching updatedAt.
+                // Counterpart dedup still keeps each person's newest opportunity; no
+                // composition capping because the caller wants the full pipeline.
+                const newestFirst = [...visibleForRadar].sort((a, b) => safeParseDate(b.createdAt) - safeParseDate(a.createdAt));
                 const seenIds = new Set();
                 const dedupedByCounterpart = newestFirst.filter((opp) => {
                     const counterpartIds = getUniqueCounterpartUserIds(opp, state.userId);
@@ -251,32 +224,11 @@ export async function loadOpportunitiesNode(state, deps) {
                         seenIds.add(id);
                     return true;
                 });
-                // Preserve byte-identical newest-first behavior while the flag is
-                // off. When on, re-order the already-deduped lifecycle set by
-                // adjusted confidence so each client-side radar bucket reflects
-                // pool answers immediately.
-                if (!poolRankingProvenance ||
-                    !dedupedByCounterpart.some((opportunity) => hasPoolAdjustment(opportunity, poolRankingProvenance))) {
-                    return { opportunities: dedupedByCounterpart.slice(0, state.limit) };
-                }
-                const adjustedOrder = [...dedupedByCounterpart].sort((a, b) => {
-                    const confidenceDelta = getConfidence(b, poolRankingProvenance) - getConfidence(a, poolRankingProvenance);
-                    if (confidenceDelta !== 0)
-                        return confidenceDelta;
-                    return safeParseDate(b.updatedAt) - safeParseDate(a.updatedAt);
-                });
-                return { opportunities: adjustedOrder.slice(0, state.limit) };
+                return { opportunities: dedupedByCounterpart.slice(0, state.limit) };
             }
             const sorted = [...visibleForRadar].sort((a, b) => {
-                // Connections before connector-flow so dedup claims counterpart IDs
-                // for direct connections first — prevents introducer cards from
-                // shadowing a user's own connection opportunities.
-                const aIsIntroducer = a.actors.some((ac) => ac.userId === state.userId && ac.role === 'introducer');
-                const bIsIntroducer = b.actors.some((ac) => ac.userId === state.userId && ac.role === 'introducer');
-                if (aIsIntroducer !== bIsIntroducer)
-                    return aIsIntroducer ? 1 : -1;
-                const confA = getConfidence(a, poolRankingProvenance);
-                const confB = getConfidence(b, poolRankingProvenance);
+                const confA = getRawConfidence(a);
+                const confB = getRawConfidence(b);
                 if (confB !== confA)
                     return confB - confA;
                 const aTime = safeParseDate(a.updatedAt);
@@ -304,8 +256,7 @@ export async function loadOpportunitiesNode(state, deps) {
 }
 export async function checkPresenterCacheNode(state, deps) {
     return timed("RadarGraph.checkPresenterCache", async () => {
-        const { opportunities, userId } = state;
-        const poolRankingProvenance = getPoolRankingProvenance(state);
+        const { opportunities, userId, scopeId } = state;
         if (opportunities.length === 0) {
             return { cachedCards: new Map(), uncachedOpportunities: [] };
         }
@@ -323,7 +274,7 @@ export async function checkPresenterCacheNode(state, deps) {
             // transitions (e.g. negotiating → pending) don't serve stale cards.
             const cacheable = opportunities.filter((opp) => opp.status !== 'negotiating');
             const liveNegotiating = opportunities.filter((opp) => opp.status === 'negotiating');
-            const keys = cacheable.map((opp) => buildRadarCardPresentationCacheKey(opp.id, opp.status, userId));
+            const keys = cacheable.map((opp) => buildRadarCardPresentationCacheKey(opp.id, opp.status, userId, scopeId));
             const results = keys.length > 0 ? await deps.cache.mget(keys) : [];
             const cachedCards = new Map();
             const uncachedOpportunities = [...liveNegotiating];
@@ -333,13 +284,9 @@ export async function checkPresenterCacheNode(state, deps) {
                     const originalIndex = opportunities.indexOf(cacheable[i]);
                     // Stamp the live status: pre-status cache entries lack the field,
                     // and the key already guarantees it matches the current status.
-                    const deprioritizedReason = poolRankingProvenance
-                        ? latestPoolDemotionDetail(cacheable[i].metadata, poolRankingProvenance)
-                        : undefined;
                     cachedCards.set(cacheable[i].id, {
                         ...cached,
                         status: cacheable[i].status,
-                        deprioritizedReason,
                         _cardIndex: originalIndex,
                     });
                 }
@@ -360,7 +307,7 @@ export async function checkPresenterCacheNode(state, deps) {
         }
     });
 }
-export function shouldGenerateCards(state, deps) {
+export function shouldGenerateCards(state, _deps) {
     if (state.uncachedOpportunities.length > 0) {
         return 'generate';
     }
@@ -404,34 +351,14 @@ export async function generateCardTextNode(state, deps) {
                 const cardIndex = oppIndexMap.get(opportunity.id) ?? (i + offset);
                 const viewerActor = opportunity.actors.find((a) => a.userId === state.userId);
                 const viewerRole = viewerActor?.role ?? 'party';
-                const isIntroducer = viewerRole === 'introducer';
                 const preferredActor = pickDisplayCounterpartActor(opportunity, state.userId)
-                    ?? opportunity.actors.find((a) => a.userId !== state.userId && a.role !== 'introducer');
-                const actorWithProfile = opportunity.actors.find((a) => a.userId !== state.userId && a.role !== 'introducer' && !!userMap.get(a.userId));
-                const introducer = opportunity.actors.find((a) => a.role === 'introducer');
-                let otherActor = (preferredActor && userMap.get(preferredActor.userId))
+                    ?? opportunity.actors.find((a) => a.userId !== state.userId);
+                const actorWithProfile = opportunity.actors.find((a) => a.userId !== state.userId && !!userMap.get(a.userId));
+                const otherActor = (preferredActor && userMap.get(preferredActor.userId))
                     ? preferredActor
                     : (actorWithProfile ?? preferredActor);
-                // When the only other participant is the introducer (no separate party), use introducer as display counterpart so the card shows a name instead of "Unknown"
-                if (!otherActor && introducer && introducer.userId !== state.userId && introducer.userId) {
-                    otherActor = { userId: introducer.userId, role: introducer.role };
-                }
                 const otherUser = otherActor ? userMap.get(otherActor.userId) ?? null : null;
-                const introducerCounterparts = opportunity.actors.filter((a) => a.userId !== state.userId && a.role !== 'introducer');
-                // Deduplicate by userId — actors array can contain multiple rows per user
-                // (e.g. from different intents), which would produce repeated names.
-                const uniqueCounterpartIds = [...new Set(introducerCounterparts.map((a) => a.userId))];
-                const participantNames = uniqueCounterpartIds
-                    .map((uid) => userMap.get(uid)?.name ?? 'Unknown')
-                    .sort();
-                // When secondPartyData will be present (2+ counterparts), use single counterpart name
-                // because the frontend arrow layout renders "card.name → secondParty.name".
-                // Using the joined "A ↔ B" format here would produce redundant "A ↔ B → B".
-                // Only use the joined format when there is a single counterpart (no arrow layout).
-                const willHaveSecondParty = isIntroducer && uniqueCounterpartIds.length > 1;
-                let userName = isIntroducer && participantNames.length > 0 && !willHaveSecondParty
-                    ? participantNames.join(' ↔ ')
-                    : (otherUser?.name ?? 'Unknown');
+                let userName = otherUser?.name ?? 'Unknown';
                 // Fallback to profile identity name when users.name is missing (e.g. profile has display name, users row does not)
                 if ((userName === 'Unknown' || !userName?.trim()) && otherActor?.userId && db.getProfile) {
                     const profile = await db.getProfile(otherActor.userId).catch((err) => {
@@ -465,19 +392,6 @@ export async function generateCardTextNode(state, deps) {
                     maxChars: MAX_REASONING_SNIPPET_LENGTH,
                     emptyText: 'A promising connection.',
                 });
-                // Build secondParty for introducer arrow layout (the party that isn't the display counterpart)
-                let secondPartyData;
-                if (isIntroducer && introducerCounterparts.length > 1 && otherActor) {
-                    const secondActor = introducerCounterparts.find((a) => a.userId !== otherActor.userId);
-                    if (secondActor) {
-                        const secondUser = userMap.get(secondActor.userId) ?? null;
-                        secondPartyData = {
-                            name: secondUser?.name ?? 'Unknown',
-                            avatar: secondUser?.avatar ?? null,
-                            userId: secondActor.userId,
-                        };
-                    }
-                }
                 // Skeleton presentation: return an identity-only card without the
                 // deps.presenter LLM or negotiation-context load. Name resolution and
                 // the unresolvable-counterpart drop above still apply, so the card
@@ -493,39 +407,32 @@ export async function generateCardTextNode(state, deps) {
                         cta: '',
                         primaryActionLabel: getPrimaryActionLabel(viewerRole),
                         secondaryActionLabel: SECONDARY_ACTION_LABEL,
-                        mutualIntentsLabel: isIntroducer ? 'Connector match' : 'Shared interests',
+                        mutualIntentsLabel: 'Shared interests',
                         viewerRole,
-                        ...(secondPartyData ? { secondParty: secondPartyData } : {}),
                         presentationPending: true,
                         _cardIndex: cardIndex,
                     };
                 }
-                const isPendingIntroducerFallback = isIntroducer && opportunity.status !== 'latent';
-                const fallbackCard = () => ({
+                const fallbackCard = (outcomeReasoning) => ({
                     opportunityId: opportunity.id,
                     status: opportunity.status,
                     userId: otherActor?.userId ?? '',
                     name: userName,
                     avatar: userAvatar,
-                    mainText: reasoningSnippet,
-                    cta: isIntroducer
-                        ? (isPendingIntroducerFallback ? 'Share this introduction to get things started.' : 'Take a look and decide if this is a good match.')
-                        : 'Take a look and decide whether to reach out.',
+                    mainText: outcomeReasoning ?? reasoningSnippet,
+                    cta: 'Take a look and decide whether to reach out.',
                     primaryActionLabel: getPrimaryActionLabel(viewerRole),
                     secondaryActionLabel: SECONDARY_ACTION_LABEL,
-                    mutualIntentsLabel: isIntroducer ? 'Connector match' : 'Shared interests',
-                    narratorChip: isIntroducer
-                        ? { name: 'You', text: 'Worth a look.', userId: state.userId }
-                        : { name: 'Index', text: 'Worth a look.' },
+                    mutualIntentsLabel: 'Shared interests',
+                    narratorChip: { name: 'Index', text: 'Worth a look.' },
                     viewerRole,
-                    ...(secondPartyData ? { secondParty: secondPartyData } : {}),
                     _presentationFallback: true,
                     _cardIndex: cardIndex,
                 });
                 try {
                     const [ctx, negotiationContext] = await Promise.all([
-                        gatherPresenterContext(db, opportunity, state.userId, otherActor?.userId),
-                        loadNegotiationContext(db, opportunity.id, opportunity.status),
+                        gatherPresenterContext(db, opportunity, state.userId, otherActor?.userId, state.scopeId),
+                        loadNegotiationContext(db, opportunity.id, opportunity.status, state.userId),
                     ]);
                     const presenterInput = {
                         ...ctx,
@@ -543,26 +450,8 @@ export async function generateCardTextNode(state, deps) {
                     if (presentation.isFallback) {
                         return fallbackCard();
                     }
-                    let narratorChip;
-                    // Only show a person as narrator when they are the introducer and not the display counterpart
-                    // (bad data can have same user as introducer and party, e.g. "Amina introduced you to Amina")
-                    const introducerIsCounterpart = introducer && otherActor && introducer.userId === otherActor.userId;
-                    if (introducer && introducer.userId !== state.userId && !introducerIsCounterpart) {
-                        const introUser = userMap.get(introducer.userId) ?? null;
-                        const narratorName = introUser?.name ?? 'Someone';
-                        narratorChip = {
-                            name: narratorName,
-                            text: stripLeadingNarratorName(presentation.narratorRemark, narratorName),
-                            avatar: introUser?.avatar ?? null,
-                            userId: introducer.userId,
-                        };
-                    }
-                    else if (introducer?.userId === state.userId) {
-                        narratorChip = { name: 'You', text: presentation.narratorRemark, userId: state.userId };
-                    }
-                    else {
-                        narratorChip = { name: 'Index', text: presentation.narratorRemark };
-                    }
+                    // Every card is system-discovered now: one narrator.
+                    const narratorChip = { name: 'Index', text: presentation.narratorRemark };
                     return {
                         opportunityId: opportunity.id,
                         status: opportunity.status,
@@ -577,7 +466,6 @@ export async function generateCardTextNode(state, deps) {
                         mutualIntentsLabel: presentation.mutualIntentsLabel,
                         narratorChip,
                         viewerRole,
-                        ...(secondPartyData ? { secondParty: secondPartyData } : {}),
                         _cardIndex: cardIndex,
                     };
                 }
@@ -598,18 +486,9 @@ export async function generateCardTextNode(state, deps) {
 }
 export async function cachePresenterResultsNode(state, deps) {
     return timed("RadarGraph.cachePresenterResults", async () => {
-        const { cards, cachedCards, userId, opportunities } = state;
-        const poolRankingProvenance = getPoolRankingProvenance(state);
-        const liveById = new Map(opportunities.map((opportunity) => [opportunity.id, opportunity]));
-        const cardsWithAdjustments = cards.map((card) => {
-            const opportunity = liveById.get(card.opportunityId);
-            const deprioritizedReason = poolRankingProvenance
-                ? latestPoolDemotionDetail(opportunity?.metadata, poolRankingProvenance)
-                : undefined;
-            return { ...card, deprioritizedReason };
-        });
+        const { cards, cachedCards, userId, opportunities, scopeId } = state;
         // Only cache cards that weren't already from cache
-        const newCards = cardsWithAdjustments.filter((card) => !cachedCards.has(card.opportunityId));
+        const newCards = cards.filter((card) => !cachedCards.has(card.opportunityId));
         const statusById = new Map(opportunities.map((opp) => [opp.id, opp.status]));
         try {
             await Promise.all(newCards.map((card) => {
@@ -618,16 +497,16 @@ export async function cachePresenterResultsNode(state, deps) {
                 // safe for the current response but must not become 24h entries.
                 if (!status || !isRadarPresentationCacheable(card, status))
                     return Promise.resolve();
-                return deps.cache.set(buildRadarCardPresentationCacheKey(card.opportunityId, status, userId), card, { ttl: RADAR_CACHE_TTL });
+                return deps.cache.set(buildRadarCardPresentationCacheKey(card.opportunityId, status, userId, scopeId), card, { ttl: RADAR_CACHE_TTL });
             }));
         }
         catch (e) {
             cachePresenterResultsLog.warn('cache write failed, continuing', { error: e });
         }
         // Merge cached cards into full card list
-        const allCards = [...cardsWithAdjustments];
+        const allCards = [...cards];
         for (const [oppId, cachedCard] of cachedCards) {
-            if (!cardsWithAdjustments.some((card) => card.opportunityId === oppId)) {
+            if (!cards.some((card) => card.opportunityId === oppId)) {
                 allCards.push(cachedCard);
             }
         }
@@ -646,9 +525,10 @@ export async function cachePresenterResultsNode(state, deps) {
 export async function normalizeItemsNode(state) {
     return timed("RadarGraph.normalizeItems", async () => {
         normalizeItemsLog.verbose('entry', { cardsLength: state.cards.length });
+        const createdAtById = new Map(state.opportunities.map((opportunity) => [opportunity.id, opportunity.createdAt.toISOString()]));
         const items = state.cards.map((card) => {
             const { _cardIndex, _presentationFallback, ...rest } = card;
-            return rest;
+            return { ...rest, createdAt: createdAtById.get(card.opportunityId) };
         });
         const meta = { totalOpportunities: state.opportunities.length };
         normalizeItemsLog.verbose('exit', { totalOpportunities: meta.totalOpportunities, totalItems: items.length });

package/dist/{opportunities → internal/opportunities}/radar/radar.state.d.ts

@@ -1,10 +1,11 @@
-import type { Opportunity, OpportunityStatus } from '../../shared/interfaces/database.interface.js';
-import type { DebugMetaAgent } from '../../agents/agent.module.js';
+import type { Opportunity, OpportunityStatus } from '../../../platform/database.js';
+import type { DebugMetaAgent } from "../../../protocol/core.js";
 /**
  * Radar card item: one opportunity with full presenter-driven display contract.
  */
 export interface RadarCardItem {
     opportunityId: string;
+    createdAt?: string;
     /** Lifecycle status of the underlying opportunity at render time (client bucketing, e.g. intent radar). */
     status?: OpportunityStatus;
     userId: string;
@@ -25,16 +26,8 @@ export interface RadarCardItem {
         avatar?: string | null;
         userId?: string;
     };
-    /** Viewer's role in this opportunity (e.g. 'introducer', 'party', 'agent', 'patient', 'peer'). */
+    /** Viewer's role in this opportunity (e.g. 'party', 'agent', 'patient', 'peer'). */
     viewerRole?: string;
-    /** Template-only explanation for a pool-answer demotion (never evaluator reasoning). */
-    deprioritizedReason?: string;
-    /** Second party in introducer arrow layout. Present when viewerRole is 'introducer'. */
-    secondParty?: {
-        name: string;
-        avatar?: string | null;
-        userId?: string;
-    };
     /**
      * True when this card was produced by a skeleton-presentation run: identity
      * fields (name/avatar/status) are real but mainText/cta are empty because the

package/dist/{shared → internal/shared}/agent/model-signal.d.ts

@@ -1,6 +1,6 @@
 /**
  * Returns a LangChain RunnableConfig carrying the active AbortSignal(s),
- * when tool/runtime execution installed one in AsyncLocalStorage or a caller
+ * when the host installed one in AsyncLocalStorage or a caller
  * supplied an explicit signal.
  */
 export declare function getAbortSignalConfig(signal?: AbortSignal): {

package/dist/{shared → internal/shared}/agent/model-signal.js

@@ -24,7 +24,7 @@ function combineAbortSignals(signals) {
 }
 /**
  * Returns a LangChain RunnableConfig carrying the active AbortSignal(s),
- * when tool/runtime execution installed one in AsyncLocalStorage or a caller
+ * when the host installed one in AsyncLocalStorage or a caller
  * supplied an explicit signal.
  */
 export function getAbortSignalConfig(signal) {