@indexnetwork/protocol 8.3.0-rc.424.1 → 8.4.0-rc.426.1

package/dist/opportunity/{feed/feed.graph.js → radar/radar.graph.js}

@@ -1,39 +1,35 @@
 /**
- * Home Graph: Build the opportunity home view with dynamic sections.
+ * 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:
- * loadOpportunities → checkPresenterCache → [generateCardText if misses] → cachePresenterResults
- * → checkCategorizerCache → [categorizeDynamically if miss] → cacheCategorizerResults → normalizeAndSort
+ * loadOpportunities → checkPresenterCache → [generateCardText if misses]
+ * → cachePresenterResults → normalizeItems
  *
- * Uses OpportunityPresenter for card text and an LLM to categorize cards into dynamic sections
- * with titles and Lucide icon names. Caches presenter and categorizer results via OpportunityCache.
+ * Uses OpportunityPresenter for card text and caches presenter results via
+ * OpportunityCache. Responses are a flat `items` array; clients bucket by
+ * lifecycle status themselves.
  */
-import { createHash } from 'crypto';
 import { StateGraph, START, END } from '@langchain/langgraph';
-import { HomeGraphState } from './feed.state.js';
+import { RadarGraphState } from './radar.state.js';
 import { OpportunityPresenter, gatherPresenterContext } from '../opportunity.presenter.js';
 import { loadNegotiationContext } from '../negotiation-context.loader.js';
-import { HomeCategorizerAgent } from './feed.categorizer.js';
 import { canUserSeeOpportunity, isActionableForViewer, selectByComposition } from '../opportunity.utils.js';
-import { resolveHomeSectionIcon, DEFAULT_HOME_SECTION_ICON } from '../../shared/ui/lucide.icon-catalog.js';
 import { getPrimaryActionLabel, SECONDARY_ACTION_LABEL } from '../opportunity.labels.js';
 import { safeFallbackSummary } from '../opportunity.safe-presentation.js';
-import { buildHomeCardPresentationCacheKey, buildHomeCategoryPresentationCacheKey } from '../opportunity.presentation-cache.js';
+import { buildRadarCardPresentationCacheKey } from '../opportunity.presentation-cache.js';
 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('HomeGraph');
-const checkCategorizerCacheLog = protocolLogger('HomeGraph:checkCategorizerCache');
-const cacheCategorizerResultsLog = protocolLogger('HomeGraph:cacheCategorizerResults');
-const checkPresenterCacheLog = protocolLogger('HomeGraph:checkPresenterCache');
-const cachePresenterResultsLog = protocolLogger('HomeGraph:cachePresenterResults');
-const categorizeDynamicallyLog = protocolLogger('HomeGraph:categorizeDynamically');
-const normalizeAndSortLog = protocolLogger('HomeGraph:normalizeAndSort');
-const generateCardTextLog = protocolLogger('HomeGraph:generateCardText');
-/** Default home-feed statuses: the lifecycle stages a viewer can act on today. */
-export const DEFAULT_HOME_STATUSES = ['latent', 'pending'];
+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'];
 // 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.
@@ -47,14 +43,13 @@ const OPPORTUNITY_STATUS_REGISTRY = {
     rejected: true,
     expired: true,
 };
-/** Full status enumeration. Pass this to `HomeGraphInvokeInput.statuses` to restore pre-Issue-3 (unfiltered) behavior. */
+/** Full status enumeration. Pass this to `RadarGraphInvokeInput.statuses` to restore pre-Issue-3 (unfiltered) behavior. */
 export const ALL_OPPORTUNITY_STATUSES = Object.keys(OPPORTUNITY_STATUS_REGISTRY);
-const MAX_ITEMS_PER_SECTION = 20;
 const PRESENTATION_CONCURRENCY = 50;
 const MAX_REASONING_SNIPPET_LENGTH = 240;
-const HOME_CACHE_TTL = 24 * 60 * 60; // 24 hours in seconds
+const RADAR_CACHE_TTL = 24 * 60 * 60; // 24 hours in seconds
 /** Pure cache policy for presenter cards; degraded current-request copy retries later. */
-export function isHomePresentationCacheable(card, status) {
+export function isRadarPresentationCacheable(card, status) {
     return Boolean(status &&
         status !== 'negotiating' &&
         !card.presentationPending &&
@@ -62,12 +57,6 @@ export function isHomePresentationCacheable(card, status) {
         card.name &&
         card.name !== 'Unknown');
 }
-/** Redis key for the categorizer cache, derived from the user and the ordered opportunity-id set. */
-function buildCategorizerCacheKey(userId, cards) {
-    const oppIds = cards.map((c) => c.opportunityId).join(',');
-    const hash = createHash('sha256').update(oppIds).digest('hex').slice(0, 16);
-    return buildHomeCategoryPresentationCacheKey(userId, hash);
-}
 /**
  * Strip leading narrator name from remark when the UI already prepends "Name: " to the chip.
  * Avoids duplication like "Yankı Ekin Yüksel: Yankı Ekin Yüksel introduced you two..."
@@ -102,7 +91,8 @@ const safeParseDate = (value) => {
         return value;
     if (typeof value === 'string') {
         const t = new Date(value).getTime();
-        return Number.isFinite(t) ? t : 0;
+        if (!Number.isNaN(t))
+            return t;
     }
     return 0;
 };
@@ -129,7 +119,7 @@ const getRawConfidence = (opp) => {
 /**
  * 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 feed.
+ * 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) => {
@@ -178,25 +168,24 @@ const pickDisplayCounterpartActor = (opportunity, viewerId) => {
     });
     return sorted[0] ?? null;
 };
-export class HomeGraphFactory {
+export class RadarGraphFactory {
     constructor(database, cache) {
         this.database = database;
         this.cache = cache;
     }
     createGraph() {
         const presenter = new OpportunityPresenter();
-        const categorizer = new HomeCategorizerAgent();
         const loadOpportunitiesNode = async (state) => {
-            return timed("HomeGraph.loadOpportunities", async () => {
+            return timed("RadarGraph.loadOpportunities", async () => {
                 if (!state.userId) {
                     return { error: 'userId is required' };
                 }
                 try {
-                    // Minimum of 50 ensures enough candidates across all feed categories
+                    // Minimum of 50 ensures enough candidates across all radar categories
                     // (connection, connector-flow, 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_HOME_STATUSES;
+                    const statuses = state.statuses ?? DEFAULT_RADAR_STATUSES;
                     const poolRankingProvenance = getPoolRankingProvenance(state);
                     const options = {
                         limit: fetchLimit,
@@ -208,7 +197,7 @@ export class HomeGraphFactory {
                         options.scopeType = 'intent';
                         options.scopeId = state.scopeId;
                     }
-                    // Do not pass conversationId: home view excludes draft opportunities (chat-only drafts).
+                    // Do not pass conversationId: radar view excludes draft opportunities (chat-only drafts).
                     const raw = await this.database.getOpportunitiesForUser(state.userId, options);
                     const visible = raw.filter((opp) => canUserSeeOpportunity(opp.actors, opp.status, state.userId));
                     // Actionability only gates the live statuses a viewer could act on:
@@ -220,7 +209,7 @@ export class HomeGraphFactory {
                     // The requested-status membership check is defense-in-depth: rows
                     // outside the requested set are dropped even if the adapter drifts.
                     const requestedStatuses = new Set(statuses);
-                    const visibleForFeed = visible.filter((opp) => {
+                    const visibleForRadar = visible.filter((opp) => {
                         if (!requestedStatuses.has(opp.status))
                             return false;
                         if (opp.status === 'latent' || opp.status === 'pending') {
@@ -234,7 +223,7 @@ export class HomeGraphFactory {
                         // 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 = [...visibleForFeed].sort((a, b) => safeParseDate(b.updatedAt) - safeParseDate(a.updatedAt));
+                        const newestFirst = [...visibleForRadar].sort((a, b) => safeParseDate(b.updatedAt) - safeParseDate(a.updatedAt));
                         const seenIds = new Set();
                         const dedupedByCounterpart = newestFirst.filter((opp) => {
                             const counterpartIds = getUniqueCounterpartUserIds(opp, state.userId);
@@ -261,7 +250,7 @@ export class HomeGraphFactory {
                         });
                         return { opportunities: adjustedOrder.slice(0, state.limit) };
                     }
-                    const sorted = [...visibleForFeed].sort((a, b) => {
+                    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.
@@ -291,13 +280,13 @@ export class HomeGraphFactory {
                     return { opportunities };
                 }
                 catch (e) {
-                    logger.error('HomeGraph loadOpportunities failed', { error: e });
+                    logger.error('RadarGraph loadOpportunities failed', { error: e });
                     return { error: 'Failed to load opportunities', opportunities: [] };
                 }
             });
         };
         const checkPresenterCacheNode = async (state) => {
-            return timed("HomeGraph.checkPresenterCache", async () => {
+            return timed("RadarGraph.checkPresenterCache", async () => {
                 const { opportunities, userId } = state;
                 const poolRankingProvenance = getPoolRankingProvenance(state);
                 if (opportunities.length === 0) {
@@ -317,7 +306,7 @@ export class HomeGraphFactory {
                     // 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) => buildHomeCardPresentationCacheKey(opp.id, opp.status, userId));
+                    const keys = cacheable.map((opp) => buildRadarCardPresentationCacheKey(opp.id, opp.status, userId));
                     const results = keys.length > 0 ? await this.cache.mget(keys) : [];
                     const cachedCards = new Map();
                     const uncachedOpportunities = [...liveNegotiating];
@@ -362,14 +351,14 @@ export class HomeGraphFactory {
             return 'skip';
         };
         const generateCardTextNode = async (state) => {
-            return timed("HomeGraph.generateCardText", async () => {
+            return timed("RadarGraph.generateCardText", async () => {
                 const opportunities = state.uncachedOpportunities.length > 0
                     ? state.uncachedOpportunities
                     : state.opportunities;
                 generateCardTextLog.verbose('entry', { opportunitiesLength: opportunities.length, userId: state.userId });
                 if (opportunities.length === 0) {
-                    generateCardTextLog.verbose('exit', { totalOpportunities: 0, totalSections: 0 });
-                    return { cards: [], agentTimings: [], meta: { totalOpportunities: 0, totalSections: 0 } };
+                    generateCardTextLog.verbose('exit', { totalOpportunities: 0 });
+                    return { cards: [], agentTimings: [], meta: { totalOpportunities: 0 } };
                 }
                 const db = this.database;
                 const cards = [];
@@ -441,9 +430,9 @@ export class HomeGraphFactory {
                         // "Unknown" placeholder: such cards are unusable, excluded from the
                         // presenter cache (see cachePresenterResults), and would otherwise
                         // trigger a fresh presenter LLM call on every request — a permanent
-                        // cache miss that keeps the whole feed slow (~9s per load).
+                        // cache miss that keeps the whole radar slow (~9s per load).
                         if (userName === 'Unknown' || !userName?.trim()) {
-                            logger.verbose('[HomeGraph:generateCardText] dropping card with unresolvable counterpart', {
+                            logger.verbose('[RadarGraph:generateCardText] dropping card with unresolvable counterpart', {
                                 opportunityId: opportunity.id,
                                 otherActorUserId: otherActor?.userId,
                             });
@@ -524,7 +513,7 @@ export class HomeGraphFactory {
                                 gatherPresenterContext(db, opportunity, state.userId, otherActor?.userId),
                                 loadNegotiationContext(db, opportunity.id, opportunity.status),
                             ]);
-                            const homeInput = {
+                            const presenterInput = {
                                 ...ctx,
                                 mutualIntentCount: undefined,
                                 opportunityStatus: opportunity.status,
@@ -533,7 +522,7 @@ export class HomeGraphFactory {
                             const _traceEmitterPresenter = requestContext.getStore()?.traceEmitter;
                             const presenterStart = Date.now();
                             _traceEmitterPresenter?.({ type: "agent_start", name: "opportunity-presenter" });
-                            const presentation = await presenter.presentHomeCard(homeInput);
+                            const presentation = await presenter.presentCard(presenterInput);
                             const _presenterDuration = Date.now() - presenterStart;
                             agentTimingsAccum.push({ name: 'opportunity.presenter', durationMs: _presenterDuration });
                             _traceEmitterPresenter?.({ type: "agent_end", name: "opportunity-presenter", durationMs: _presenterDuration, summary: `Presented: ${userName}` });
@@ -580,22 +569,22 @@ export class HomeGraphFactory {
                             };
                         }
                         catch (e) {
-                            logger.warn('HomeGraph presenter failed for opportunity', { opportunityId: opportunity.id, error: e });
+                            logger.warn('RadarGraph presenter failed for opportunity', { opportunityId: opportunity.id, error: e });
                             return fallbackCard();
                         }
                     }));
                     cards.push(...chunkCards.filter((c) => c !== null));
                 }
-                generateCardTextLog.verbose('exit', { totalOpportunities: state.opportunities.length, totalSections: 0 });
+                generateCardTextLog.verbose('exit', { totalOpportunities: state.opportunities.length });
                 return {
                     cards,
                     agentTimings: agentTimingsAccum,
-                    meta: { totalOpportunities: state.opportunities.length, totalSections: 0 },
+                    meta: { totalOpportunities: state.opportunities.length },
                 };
             });
         };
         const cachePresenterResultsNode = async (state) => {
-            return timed("HomeGraph.cachePresenterResults", async () => {
+            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]));
@@ -614,9 +603,9 @@ export class HomeGraphFactory {
                         const status = statusById.get(card.opportunityId);
                         // Negotiating, skeleton, fallback, and unresolved-name cards are
                         // safe for the current response but must not become 24h entries.
-                        if (!status || !isHomePresentationCacheable(card, status))
+                        if (!status || !isRadarPresentationCacheable(card, status))
                             return Promise.resolve();
-                        return this.cache.set(buildHomeCardPresentationCacheKey(card.opportunityId, status, userId), card, { ttl: HOME_CACHE_TTL });
+                        return this.cache.set(buildRadarCardPresentationCacheKey(card.opportunityId, status, userId), card, { ttl: RADAR_CACHE_TTL });
                     }));
                 }
                 catch (e) {
@@ -637,173 +626,28 @@ export class HomeGraphFactory {
                 });
                 return {
                     cards: allCards,
-                    meta: { totalOpportunities: state.opportunities.length, totalSections: 0 },
+                    meta: { totalOpportunities: state.opportunities.length },
                 };
             });
         };
-        const checkCategorizerCacheNode = async (state) => {
-            return timed("HomeGraph.checkCategorizerCache", async () => {
-                if (state.cards.length === 0) {
-                    return { categoryCacheHit: false };
-                }
-                // Skeleton runs never categorize (some cards have no text to categorize
-                // and the response must stay LLM-free). Ranking-enabled lifecycle views
-                // also stay flat: the intent Radar flattens sections and buckets by
-                // status, so dynamic categorization would erase the adjusted order on
-                // the full second-phase response. Flag off retains the legacy path.
-                // Chunk by MAX_ITEMS_PER_SECTION because normalizeAndSort caps sections.
-                const poolRankingProvenance = getPoolRankingProvenance(state);
-                const preserveAdjustedLifecycleOrder = (state.statuses?.length ?? 0) > 0 &&
-                    poolRankingProvenance !== null &&
-                    state.opportunities.some((opportunity) => hasPoolAdjustment(opportunity, poolRankingProvenance));
-                if (state.presentation === 'skeleton' || preserveAdjustedLifecycleOrder) {
-                    const sectionProposals = [];
-                    for (let start = 0; start < state.cards.length; start += MAX_ITEMS_PER_SECTION) {
-                        sectionProposals.push({
-                            id: `all-${sectionProposals.length + 1}`,
-                            title: 'All matches',
-                            iconName: DEFAULT_HOME_SECTION_ICON,
-                            itemIndices: state.cards.slice(start, start + MAX_ITEMS_PER_SECTION).map((_, i) => start + i),
-                        });
-                    }
-                    return { sectionProposals, categoryCacheHit: true };
-                }
-                if (state.noCache) {
-                    checkCategorizerCacheLog.verbose('noCache=true, skipping cache');
-                    return { categoryCacheHit: false };
-                }
-                try {
-                    const key = buildCategorizerCacheKey(state.userId, state.cards);
-                    const cached = await this.cache.get(key);
-                    if (cached) {
-                        checkCategorizerCacheLog.verbose('cache hit');
-                        return { sectionProposals: cached, categoryCacheHit: true };
-                    }
-                    checkCategorizerCacheLog.verbose('cache miss');
-                }
-                catch (e) {
-                    checkCategorizerCacheLog.warn('cache unavailable, skipping', { error: e });
-                }
-                return { categoryCacheHit: false };
-            });
-        };
-        const shouldCategorize = (state) => {
-            if (state.categoryCacheHit) {
-                logger.verbose('Categorizer results cached, skipping');
-                return 'skip';
-            }
-            return 'categorize';
-        };
-        const categorizeDynamicallyNode = async (state) => {
-            return timed("HomeGraph.categorizeDynamically", async () => {
-                categorizeDynamicallyLog.verbose('entry', { cardsLength: state.cards.length });
-                if (state.cards.length === 0) {
-                    categorizeDynamicallyLog.verbose('exit', { sectionProposalsCount: 0 });
-                    return { sectionProposals: [], agentTimings: [] };
-                }
-                const agentTimingsAccum = [];
-                const categorizerInput = state.cards.map((c) => ({
-                    index: c._cardIndex,
-                    headline: c.headline,
-                    mainText: c.mainText,
-                    name: c.name,
-                    viewerRole: c.viewerRole === 'introducer' ? 'introducer' : undefined,
-                    opportunityStatus: c.viewerRole === 'introducer' ? 'pending' : undefined,
-                }));
-                const _traceEmitterCategorizer = requestContext.getStore()?.traceEmitter;
-                const categorizerStart = Date.now();
-                _traceEmitterCategorizer?.({ type: "agent_start", name: "home-categorizer" });
-                const { sections } = await categorizer.categorize(categorizerInput);
-                const _categorizerDuration = Date.now() - categorizerStart;
-                agentTimingsAccum.push({ name: 'home.categorizer', durationMs: _categorizerDuration });
-                _traceEmitterCategorizer?.({ type: "agent_end", name: "home-categorizer", durationMs: _categorizerDuration, summary: `Categorized into ${sections.length} section(s)` });
-                const proposals = sections.map((s) => ({
-                    ...s,
-                    itemIndices: s.itemIndices.filter((i) => i >= 0 && i < state.cards.length),
-                }));
-                categorizeDynamicallyLog.verbose('exit', { sectionProposalsCount: proposals.length });
-                return { sectionProposals: proposals, agentTimings: agentTimingsAccum };
-            });
-        };
-        const cacheCategorizerResultsNode = async (state) => {
-            return timed("HomeGraph.cacheCategorizerResults", async () => {
-                if (state.categoryCacheHit ||
-                    state.sectionProposals.length === 0 ||
-                    state.cards.some((card) => card._presentationFallback)) {
-                    return {};
-                }
-                try {
-                    const key = buildCategorizerCacheKey(state.userId, state.cards);
-                    await this.cache.set(key, state.sectionProposals, { ttl: HOME_CACHE_TTL });
-                    cacheCategorizerResultsLog.verbose('cached', {
-                        sectionCount: state.sectionProposals.length,
-                    });
-                }
-                catch (e) {
-                    cacheCategorizerResultsLog.warn('cache write failed, continuing', { error: e });
-                }
-                return {};
-            });
-        };
-        const normalizeAndSortNode = async (state) => {
-            return timed("HomeGraph.normalizeAndSort", async () => {
-                const cards = state.cards;
-                const proposals = state.sectionProposals;
-                normalizeAndSortLog.verbose('entry', { cardsLength: cards.length, proposalsLength: proposals.length });
-                if (cards.length === 0) {
-                    normalizeAndSortLog.verbose('exit', { totalOpportunities: 0, totalSections: 0 });
-                    return { sections: [], meta: { totalOpportunities: 0, totalSections: 0 } };
-                }
-                const usedIndices = new Set();
-                const sections = proposals.map((p) => {
-                    const iconName = resolveHomeSectionIcon(p.iconName);
-                    const items = p.itemIndices
-                        .filter((i) => i >= 0 && i < cards.length && !usedIndices.has(i))
-                        .slice(0, MAX_ITEMS_PER_SECTION)
-                        .map((i) => {
-                        usedIndices.add(i);
-                        const card = cards[i];
-                        const { _cardIndex, _presentationFallback, ...rest } = card;
-                        return rest;
-                    });
-                    return {
-                        id: p.id,
-                        title: p.title,
-                        subtitle: p.subtitle,
-                        iconName,
-                        items,
-                    };
+        const normalizeItemsNode = async (state) => {
+            return timed("RadarGraph.normalizeItems", async () => {
+                normalizeItemsLog.verbose('entry', { cardsLength: state.cards.length });
+                const items = state.cards.map((card) => {
+                    const { _cardIndex, _presentationFallback, ...rest } = card;
+                    return rest;
                 });
-                // Enforce category ordering: sections with connections first, then
-                // connector-flow only, then expired only. This prevents the LLM
-                // categorizer from placing introducer sections before connection sections.
-                const sectionCategoryPriority = (section) => {
-                    const hasConnection = section.items.some((item) => item.viewerRole !== 'introducer');
-                    if (hasConnection)
-                        return 0; // mixed or connection-only sections first
-                    const hasConnectorFlow = section.items.some((item) => item.viewerRole === 'introducer');
-                    if (hasConnectorFlow)
-                        return 1; // connector-flow only sections next
-                    return 2; // empty or expired sections last
-                };
-                sections.sort((a, b) => sectionCategoryPriority(a) - sectionCategoryPriority(b));
-                const meta = {
-                    totalOpportunities: state.opportunities.length,
-                    totalSections: sections.length,
-                };
-                normalizeAndSortLog.verbose('exit', { totalOpportunities: meta.totalOpportunities, totalSections: meta.totalSections });
-                return { sections, meta };
+                const meta = { totalOpportunities: state.opportunities.length };
+                normalizeItemsLog.verbose('exit', { totalOpportunities: meta.totalOpportunities, totalItems: items.length });
+                return { items, meta };
             });
         };
-        const graph = new StateGraph(HomeGraphState)
+        const graph = new StateGraph(RadarGraphState)
             .addNode('loadOpportunities', loadOpportunitiesNode)
             .addNode('checkPresenterCache', checkPresenterCacheNode)
             .addNode('generateCardText', generateCardTextNode)
             .addNode('cachePresenterResults', cachePresenterResultsNode)
-            .addNode('checkCategorizerCache', checkCategorizerCacheNode)
-            .addNode('categorizeDynamically', categorizeDynamicallyNode)
-            .addNode('cacheCategorizerResults', cacheCategorizerResultsNode)
-            .addNode('normalizeAndSort', normalizeAndSortNode)
+            .addNode('normalizeItems', normalizeItemsNode)
             .addEdge(START, 'loadOpportunities')
             .addEdge('loadOpportunities', 'checkPresenterCache')
             .addConditionalEdges('checkPresenterCache', shouldGenerateCards, {
@@ -811,14 +655,8 @@ export class HomeGraphFactory {
             skip: 'cachePresenterResults',
         })
             .addEdge('generateCardText', 'cachePresenterResults')
-            .addEdge('cachePresenterResults', 'checkCategorizerCache')
-            .addConditionalEdges('checkCategorizerCache', shouldCategorize, {
-            categorize: 'categorizeDynamically',
-            skip: 'normalizeAndSort',
-        })
-            .addEdge('categorizeDynamically', 'cacheCategorizerResults')
-            .addEdge('cacheCategorizerResults', 'normalizeAndSort')
-            .addEdge('normalizeAndSort', END);
+            .addEdge('cachePresenterResults', 'normalizeItems')
+            .addEdge('normalizeItems', END);
         return graph.compile();
     }
 }

package/dist/opportunity/{feed/feed.health.d.ts → radar/radar.health.d.ts}

@@ -1,5 +1,5 @@
-/** Input for computing feed health score. */
-export interface FeedHealthInput {
+/** Input for computing radar health score. */
+export interface RadarHealthInput {
     connectionCount: number;
     connectorFlowCount: number;
     expiredCount: number;
@@ -11,8 +11,8 @@ export interface FeedHealthInput {
     /** Score threshold below which shouldMaintain is true. Default 0.5. */
     threshold?: number;
 }
-/** Output of feed health computation. */
-export interface FeedHealthResult {
+/** Output of radar health computation. */
+export interface RadarHealthResult {
     score: number;
     breakdown: {
         composition: number;
@@ -22,10 +22,10 @@ export interface FeedHealthResult {
     shouldMaintain: boolean;
 }
 /**
- * Compute feed health score (0–1) from current feed state.
+ * Compute radar health score (0–1) from current radar state.
  * Pure function, no side effects.
  *
- * @param input - Current feed composition and timing data
+ * @param input - Current radar composition and timing data
  * @returns Health score with breakdown and maintenance recommendation
  */
-export declare function computeFeedHealth(input: FeedHealthInput): FeedHealthResult;
+export declare function computeRadarHealth(input: RadarHealthInput): RadarHealthResult;

package/dist/opportunity/{feed/feed.health.js → radar/radar.health.js}

@@ -1,4 +1,4 @@
-import { FEED_SOFT_TARGETS } from '../opportunity.utils.js';
+import { RADAR_SOFT_TARGETS } from '../opportunity.utils.js';
 const WEIGHT_COMPOSITION = 0.4;
 const WEIGHT_FRESHNESS = 0.3;
 const WEIGHT_EXPIRATION = 0.3;
@@ -10,9 +10,9 @@ const DEFAULT_THRESHOLD = 0.5;
  */
 function scoreComposition(connectionCount, connectorFlowCount, expiredCount) {
     const categories = [
-        { actual: connectionCount, target: FEED_SOFT_TARGETS.connection },
-        { actual: connectorFlowCount, target: FEED_SOFT_TARGETS.connectorFlow },
-        { actual: expiredCount, target: FEED_SOFT_TARGETS.expired },
+        { actual: connectionCount, target: RADAR_SOFT_TARGETS.connection },
+        { actual: connectorFlowCount, target: RADAR_SOFT_TARGETS.connectorFlow },
+        { actual: expiredCount, target: RADAR_SOFT_TARGETS.expired },
     ];
     let totalScore = 0;
     for (const { actual, target } of categories) {
@@ -45,15 +45,15 @@ function scoreExpirationRatio(expiredCount, totalActionable) {
     return 1 - expiredCount / total;
 }
 /**
- * Compute feed health score (0–1) from current feed state.
+ * Compute radar health score (0–1) from current radar state.
  * Pure function, no side effects.
  *
- * @param input - Current feed composition and timing data
+ * @param input - Current radar composition and timing data
  * @returns Health score with breakdown and maintenance recommendation
  */
-export function computeFeedHealth(input) {
+export function computeRadarHealth(input) {
     const { connectionCount, connectorFlowCount, expiredCount, totalActionable, lastRediscoveryAt, freshnessWindowMs, threshold = DEFAULT_THRESHOLD, } = input;
-    // Empty feed is always unhealthy
+    // Empty radar is always unhealthy
     if (totalActionable === 0 && expiredCount === 0) {
         return {
             score: 0,