fodda-mcp 1.46.31 → 1.46.97

package/dist/coverageRelevance.js

@@ -31,7 +31,8 @@
  * emerging trends"), relevance can't be judged and `evaluated: false` is
  * returned — callers keep the legacy count-only behavior.
  */
-import { getGraphs, getLiveGraphs, buildDisplayName, getRelevantGraphs, getAnalysts } from './catalogCache.js';
+import { getGraphs, getLiveGraphs, buildDisplayName, cleanDisplayName, getRelevantGraphs, getAnalysts } from './catalogCache.js';
+import { LUXURY_KEYWORDS, LUXURY_BRANDS, MASS_BUDGET_KEYWORDS, MASS_BUDGET_BRANDS } from './enrichment.js';
 /** Nominal on-topic relevance-score scale per graph tier (observed in QA:
  *  domain composites ~2.0, report vector scores ~0.8; expert sits between). */
 export const TIER_NOMINAL_SCORE = {
@@ -72,13 +73,13 @@ export function specificQueryTokens(query) {
     return [...new Set(query.toLowerCase().split(/[^a-z0-9]+/)
             .filter(t => t.length >= 2 && !GENERIC_QUERY_TOKENS.has(t)))];
 }
-function rowScore(row) {
+export function rowScore(row) {
     return row.relevance_score || row.semantic_score || row._score || row.score || 0;
 }
-function rowGraphId(row) {
+export function rowGraphId(row) {
     return row._use_this_graphId || row.graphId || row.graph_id || row.psfk_graph_slug || undefined;
 }
-function resolveRowTier(row, searchedGraphs, catalog) {
+export function resolveRowTier(row, searchedGraphs, catalog) {
     const gid = rowGraphId(row);
     let type;
     if (gid) {
@@ -125,6 +126,247 @@ export function rowMatchesQueryTokens(row, tokens, catalog) {
     }
     return false;
 }
+export function stemToken(token) {
+    let s = token.toLowerCase().trim();
+    if (s.endsWith('ies') && s.length > 4) {
+        s = s.slice(0, -3) + 'y';
+    }
+    else if (s.endsWith('es') && s.length > 4) {
+        s = s.slice(0, -2);
+    }
+    else if (s.endsWith('s') && !s.endsWith('ss') && s.length > 3) {
+        s = s.slice(0, -1);
+    }
+    return s;
+}
+/**
+ * Direct token match tier: checks if specific query tokens match directly
+ * against the row's core trend name, sectors, or trend slug/categories.
+ * Applies singular/plural folding and stem matching (e.g. "collectible" matches "Collectibles", "trading cards" matches "cards").
+ * (Used to rank direct niche matches above semantically adjacent mega-trends).
+ */
+export function rowHasDirectTokenMatch(row, tokens) {
+    if (!tokens || tokens.length === 0 || !row)
+        return false;
+    const parts = [
+        row.trendName, row.name, row.label, row.title,
+        row.trendSlug, row.slug,
+        row.sectorNames, row.sectors, row.sector,
+        row.categoryNames, row.categories, row.category,
+    ];
+    for (const arr of [row.sectors, row.sectorNames, row.categories, row.categoryNames, row.topics]) {
+        if (Array.isArray(arr))
+            parts.push(...arr);
+    }
+    const words = new Set(parts.filter((x) => typeof x === 'string').join(' ').toLowerCase().split(/[^a-z0-9]+/));
+    const stemmedWords = new Set();
+    for (const w of words) {
+        stemmedWords.add(stemToken(w));
+    }
+    for (const t of tokens) {
+        if (words.has(t))
+            return true;
+        const stemT = stemToken(t);
+        if (stemmedWords.has(stemT))
+            return true;
+        if (t.length >= 4) {
+            for (const w of words) {
+                if (w.startsWith(t) || (w.length >= 4 && t.startsWith(w)))
+                    return true;
+                const stemW = stemToken(w);
+                if (stemW.length >= 4 && stemT.length >= 4) {
+                    if (stemW.startsWith(stemT) || stemT.startsWith(stemW))
+                        return true;
+                }
+            }
+        }
+    }
+    return false;
+}
+/**
+ * Row-level brand guard: returns true if the row is NOT a mega-trend brand roster.
+ * Excludes rows with brand_count > 30 (or brandNames.length >= 10 when brand_count is absent).
+ */
+export function isRowBrandEligible(row) {
+    if (!row)
+        return false;
+    const brandCount = typeof row.brand_count === 'number'
+        ? row.brand_count
+        : (typeof row.brandCount === 'number' ? row.brandCount : undefined);
+    if (brandCount !== undefined) {
+        if (brandCount > 30)
+            return false;
+    }
+    else {
+        const rawNames = Array.isArray(row.brandNames)
+            ? row.brandNames
+            : (Array.isArray(row.brands) ? row.brands : undefined);
+        if (rawNames && rawNames.length >= 10) {
+            return false;
+        }
+    }
+    return true;
+}
+/**
+ * Evaluates whether a result row matches category/market tier qualifiers in the query
+ * (e.g. "luxury" vs "budget"). Returns a positive score boost for matching tiers,
+ * or a penalty for conflicting tiers.
+ */
+export function computeTierFit(row, query) {
+    if (!query || !row)
+        return 0;
+    const qLower = query.toLowerCase();
+    const isLuxuryQuery = [...LUXURY_KEYWORDS].some(k => qLower.includes(k));
+    const isBudgetQuery = [...MASS_BUDGET_KEYWORDS].some(k => qLower.includes(k));
+    const title = (row.trendName || row.title || row.label || row.name || '').toLowerCase();
+    const summary = (row.summary || row.description || row.trendDescription || '').toLowerCase();
+    let boost = 0;
+    // 1. Format alignment with query (e.g. pop-up / activation / experiential)
+    if (/\bpop-?ups?\b/i.test(qLower)) {
+        if (/\bpop-?ups?\b/i.test(title))
+            boost += 0.40;
+        else if (/\bpop-?ups?\b/i.test(summary))
+            boost += 0.15;
+    }
+    if (/\b(experiential|experiences?)\b/i.test(qLower)) {
+        if (/\b(experiential|experiences?)\b/i.test(title))
+            boost += 0.20;
+    }
+    if (/\bactivations?\b/i.test(qLower)) {
+        if (/\bactivations?\b/i.test(title))
+            boost += 0.15;
+    }
+    // 2. Luxury / Market Tier matching
+    if (isLuxuryQuery) {
+        // Title-level luxury match gets highest priority
+        const titleHasLuxWord = [...LUXURY_KEYWORDS].some(k => title.includes(k));
+        const titleHasLuxBrand = [...LUXURY_BRANDS].some(b => title.includes(b));
+        if (titleHasLuxWord || titleHasLuxBrand)
+            boost += 0.40;
+        // Summary-level luxury match
+        const summaryHasLux = [...LUXURY_KEYWORDS].some(k => summary.includes(k)) ||
+            [...LUXURY_BRANDS].some(b => summary.includes(b));
+        if (summaryHasLux)
+            boost += 0.25;
+        // Evidence-level luxury match
+        if (Array.isArray(row.evidence) && row.evidence.length > 0) {
+            const hasLuxEvidence = row.evidence.some((e) => {
+                const txt = `${e.title || ''} ${e.summary || ''}`.toLowerCase();
+                return [...LUXURY_BRANDS].some(b => txt.includes(b)) || [...LUXURY_KEYWORDS].some(k => txt.includes(k));
+            });
+            if (hasLuxEvidence)
+                boost += 0.35;
+            boost += 0.20; // Having verified on-topic evidence is a positive signal
+        }
+        else {
+            boost -= 0.20; // Having 0 valid evidence items penalizes the trend
+        }
+        // Mass-market penalty
+        const titleHasMass = [...MASS_BUDGET_BRANDS].some(b => title.includes(b));
+        const summaryHasMass = [...MASS_BUDGET_BRANDS].some(b => summary.includes(b));
+        if (titleHasMass || summaryHasMass)
+            boost -= 0.40;
+    }
+    else if (isBudgetQuery) {
+        const titleHasMass = [...MASS_BUDGET_BRANDS].some(b => title.includes(b)) ||
+            [...MASS_BUDGET_KEYWORDS].some(k => title.includes(k));
+        if (titleHasMass)
+            boost += 0.40;
+    }
+    return boost;
+}
+/** Normalize brand string for deduplication / comparison. */
+export function normalizeBrandKey(name) {
+    return name.toLowerCase().replace(/[^\w\s]/g, '').trim().replace(/\s+/g, ' ');
+}
+/** Build standard publisher / curator exclusion set. */
+export function buildPublisherExclusionSet(searchedGraphs = [], catalog = [], rows = []) {
+    const publisherTokens = new Set([
+        'dentsu', 'dentsu creative', 'havas', 'psfk', 'nielseniq', 'niq',
+        'wpp', 'omnicom', 'ipg', 'publicis', 'accenture', 'deloitte',
+        'mckinsey', 'bcg', 'bain', 'gartner', 'forrester', 'kantar', 'jwt',
+        'ogilvy', 'edelman', 'mccann', 'bbdo', 'tbwa', 'vml', 'leo burnett'
+    ]);
+    for (const sg of searchedGraphs) {
+        const gMeta = typeof sg === 'string' ? catalog.find(x => x.graph_id === sg) : sg;
+        if (gMeta) {
+            if (gMeta.curator)
+                publisherTokens.add(gMeta.curator.toLowerCase().trim());
+            if (gMeta.company)
+                publisherTokens.add(gMeta.company.toLowerCase().trim());
+            if (gMeta.name)
+                publisherTokens.add(gMeta.name.toLowerCase().trim());
+            for (const word of `${gMeta.curator || ''} ${gMeta.company || ''} ${gMeta.name || ''}`.toLowerCase().split(/[\s,.-]+/)) {
+                if (word.length > 2)
+                    publisherTokens.add(word);
+            }
+        }
+    }
+    for (const r of rows) {
+        if (r && r.source_label) {
+            const match = String(r.source_label).match(/\(([^)]+)\)/);
+            if (match && match[1]) {
+                const org = match[1].toLowerCase().trim();
+                publisherTokens.add(org);
+                for (const w of org.split(/[\s,.-]+/)) {
+                    if (w.length > 2)
+                        publisherTokens.add(w);
+                }
+            }
+        }
+    }
+    return publisherTokens;
+}
+/** Test whether a brand name matches publisher / curator tokens. */
+export function isPublisherBrand(brand, publisherTokens) {
+    const clean = brand.trim();
+    const norm = normalizeBrandKey(clean);
+    if (!norm)
+        return true;
+    if (publisherTokens.has(norm) || publisherTokens.has(clean.toLowerCase())) {
+        return true;
+    }
+    return [...publisherTokens].some(pt => norm === pt || norm.startsWith(`${pt} `) || norm.endsWith(` ${pt}`));
+}
+/** Extract clean, guarded brand names for a single row up to limit. */
+export function extractCleanRowBrands(row, publisherTokens, limit = 4) {
+    if (!isRowBrandEligible(row))
+        return [];
+    const rawList = [];
+    if (Array.isArray(row.brandNames))
+        rawList.push(...row.brandNames);
+    else if (typeof row.brandNames === 'string')
+        rawList.push(...row.brandNames.split('|'));
+    if (Array.isArray(row.brands))
+        rawList.push(...row.brands);
+    if (typeof row.brand === 'string' && row.brand)
+        rawList.push(row.brand);
+    if (typeof row.Brand === 'string' && row.Brand)
+        rawList.push(...row.Brand.split('|'));
+    else if (Array.isArray(row.Brand))
+        rawList.push(...row.Brand);
+    if (typeof row.company === 'string' && row.company)
+        rawList.push(row.company);
+    if (Array.isArray(row.entities?.brands))
+        rawList.push(...row.entities.brands);
+    const seen = new Set();
+    const result = [];
+    for (const b of rawList) {
+        if (typeof b === 'string' && b.trim().length > 1) {
+            const clean = b.trim();
+            const norm = normalizeBrandKey(clean);
+            if (!norm || seen.has(norm))
+                continue;
+            if (publisherTokens && isPublisherBrand(clean, publisherTokens))
+                continue;
+            seen.add(norm);
+            result.push(clean);
+            if (result.length >= limit)
+                break;
+        }
+    }
+    return result;
+}
 /**
  * Count rows that are on-topic for the query. `catalog` is injectable for
  * tests; defaults to the live graph catalog.
@@ -177,7 +419,7 @@ export function isDemandShaped(query) {
     ];
     return demandKeywords.some(pat => pat.test(q));
 }
-export function addCoverageAnnotation(data, query, searchedGraphs, limit, skipEvidenceCheck = false, catalog = getGraphs(), options) {
+export async function addCoverageAnnotation(data, query, searchedGraphs, limit, skipEvidenceCheck = false, catalog = getGraphs(), options) {
     if (!data || typeof data !== 'object')
         return data;
     let normalizedData = data;
@@ -245,8 +487,17 @@ export function addCoverageAnnotation(data, query, searchedGraphs, limit, skipEv
         if (limit !== undefined && limit < 3 && resultCount === limit) {
             isThinCount = false;
         }
+        // Evidence check guard: only evaluate evidence thinness if rows actually contain
+        // evidence arrays AND evidence was not skipped or opted out.
+        // If resultCount >= 3 and query did not request inline evidence (or evidence was stripped),
+        // missing inline evidence must NOT flag healthy results as 'thin'.
+        const hasEvidenceArrays = rows.some((r) => (Array.isArray(r.evidence) && r.evidence.length > 0) ||
+            (Array.isArray(r.evidence_items) && r.evidence_items.length > 0) ||
+            (Array.isArray(r.evidenceItems) && r.evidenceItems.length > 0) ||
+            (Array.isArray(r.trendEvidence) && r.trendEvidence.length > 0));
         let isThinEvidence = false;
-        if (!skipEvidenceCheck) {
+        const skipEvidence = skipEvidenceCheck || options?.include_evidence === false || !hasEvidenceArrays;
+        if (!skipEvidence && resultCount >= 3) {
             isThinEvidence = rows.every((r) => {
                 const count = Array.isArray(r.evidence)
                     ? r.evidence.length
@@ -276,6 +527,20 @@ export function addCoverageAnnotation(data, query, searchedGraphs, limit, skipEv
         if (isThinCount || isThinEvidence || isThinRelevance) {
             status = 'thin';
         }
+        // ── Respect Backend dataStatus / on_topic_total ──
+        // Fodda API evaluates vector similarity and relevance scores directly in the graph layer.
+        // When normalizedData.dataStatus === 'TREND_MATCH' or (on_topic_total >= 3),
+        // the backend has already confirmed that the returned trends are genuine on-topic matches.
+        // MCP's secondary heuristics should not downgrade a confirmed TREND_MATCH to 'thin'.
+        const backendOnTopicTotal = normalizedData.on_topic_total ?? options?.onTopicTotal;
+        const isBackendTrendMatch = normalizedData.dataStatus === 'TREND_MATCH' ||
+            (typeof backendOnTopicTotal === 'number' && backendOnTopicTotal >= 3);
+        if (isBackendTrendMatch && resultCount >= 3) {
+            status = 'ok';
+            if (onTopicCount !== undefined && onTopicCount < 3) {
+                onTopicCount = Math.min(resultCount, Math.max(3, typeof backendOnTopicTotal === 'number' ? backendOnTopicTotal : 3));
+            }
+        }
     }
     const isDemand = isDemandShaped(query);
     let suggestedAction = undefined;
@@ -339,10 +604,79 @@ export function addCoverageAnnotation(data, query, searchedGraphs, limit, skipEv
             ],
         };
     }
-    normalizedData.next_moves = generateNextMoves(rows, query, searchedGraphs, status, onTopicCount, suggestedAction, catalog, options?.analysts || getAnalysts(), options);
+    normalizedData.next_moves = await generateNextMoves(rows, query, searchedGraphs, status, onTopicCount, suggestedAction, catalog, options?.analysts || getAnalysts(), options);
     console.error(`[coverage] status: ${status}, results: ${resultCount}/${limit || 'default'}${onTopicCount !== undefined ? `, on-topic: ${onTopicCount}` : ''}, query: "${query}"`);
     return normalizedData;
 }
+const suggestCache = new Map();
+const SUGGEST_CACHE_TTL_MS = 10 * 60 * 1000; // 10 minutes
+const MAX_SUGGEST_CACHE_SIZE = 500;
+export function clearSuggestCacheForTesting() {
+    suggestCache.clear();
+}
+function setSuggestCacheEntry(key, sources) {
+    const now = Date.now();
+    if (suggestCache.size >= MAX_SUGGEST_CACHE_SIZE) {
+        for (const [k, v] of suggestCache.entries()) {
+            if (now - v.timestamp >= SUGGEST_CACHE_TTL_MS) {
+                suggestCache.delete(k);
+            }
+        }
+    }
+    if (suggestCache.size >= MAX_SUGGEST_CACHE_SIZE) {
+        const oldestKey = suggestCache.keys().next().value;
+        if (oldestKey)
+            suggestCache.delete(oldestKey);
+    }
+    suggestCache.set(key, { timestamp: now, sources });
+}
+export function truncateAtWordBoundary(str, maxLength) {
+    if (!str || str.length <= maxLength)
+        return str;
+    const sub = str.slice(0, maxLength);
+    const lastSpace = sub.lastIndexOf(' ');
+    if (lastSpace > 10) {
+        return sub.slice(0, lastSpace).trim();
+    }
+    return sub.trim();
+}
+export async function fetchSupplementalSuggest(query, options) {
+    const normQuery = query.toLowerCase().trim();
+    const sessionId = options?.sessionId || options?.userId || 'default';
+    const cacheKey = `${sessionId}:${normQuery}`;
+    const cached = suggestCache.get(cacheKey);
+    if (cached && (Date.now() - cached.timestamp) < SUGGEST_CACHE_TTL_MS) {
+        return cached.sources;
+    }
+    try {
+        let suggestPromise = null;
+        if (options?.suggestPromise) {
+            suggestPromise = options.suggestPromise;
+        }
+        else if (options?.suggestFn) {
+            suggestPromise = options.suggestFn(query);
+        }
+        else if (options?.foddaRequest && options?.apiKey) {
+            suggestPromise = options.foddaRequest('GET', `/v1/supplemental/suggest?query=${encodeURIComponent(query)}`, options.apiKey, options.userId || '');
+        }
+        if (!suggestPromise) {
+            return null;
+        }
+        let timer;
+        const timeoutPromise = new Promise((_, reject) => {
+            timer = setTimeout(() => reject(new Error('suggest timeout (3000ms)')), 3000);
+        });
+        const data = await Promise.race([suggestPromise, timeoutPromise]);
+        clearTimeout(timer);
+        const sources = Array.isArray(data) ? data : (Array.isArray(data?.sources) ? data.sources : []);
+        setSuggestCacheEntry(cacheKey, sources);
+        return sources;
+    }
+    catch (err) {
+        console.error(`[next_moves] suggest fetch failed: ${err.message}`);
+        return null;
+    }
+}
 /**
  * Clean and truncate a single theme candidate to <= 3 words, lowercase.
  */
@@ -394,7 +728,288 @@ export function formatThemePhrase(rawCandidates, fallback = 'emerging signals')
     }
     return `${cleanedThemes[0]} and ${cleanedThemes[1]}`;
 }
-export function generateNextMoves(rows, query, searchedGraphs, status, onTopicCount, suggestedAction, catalog = getGraphs(), analysts = getAnalysts(), options) {
+/**
+ * Cross-cutting or generic tech/strategy terms that appear across multiple domains.
+ * When evaluating domain fit, matching solely on these words does NOT constitute
+ * genuine domain overlap if the query contains a specific vertical or domain term.
+ */
+export const CROSS_CUTTING_MODIFIERS = new Set([
+    'ai', 'artificial intelligence', 'genai', 'tech', 'technology', 'trends', 'trend',
+    'insights', 'insight', 'strategy', 'strategic', 'systems', 'system',
+    'innovation', 'innovations', 'future', 'futures', 'management', 'data',
+    'analytics', 'research', 'market', 'markets', 'consumer', 'consumers',
+    'culture', 'experience', 'experiences', 'overview', 'summary', 'report',
+    'industry', 'growth', 'landscape', 'benchmarks', 'benchmark'
+]);
+/**
+ * Score and rank candidate experts for a query.
+ * Reuses the shared scoring spine: domain overlap, blind-spot exclusion,
+ * self-recommendation suppression, and honest failure.
+ */
+export function findCandidateExperts(query, options) {
+    const rawAnalysts = options?.analysts || getAnalysts();
+    const activeAnalysts = rawAnalysts.filter(a => {
+        const st = (a.status || a.Status || '').toLowerCase().trim();
+        return !st || st === 'active' || st === 'unclaimed' || st === 'on_request' || st === 'on request';
+    });
+    const isCurrentAnalyst = (a) => {
+        const excludeId = options?.currentAnalystId || options?.excludeAnalystId;
+        if (!excludeId)
+            return false;
+        const cur = excludeId.toLowerCase().trim();
+        return (a.analyst_id && a.analyst_id.toLowerCase().trim() === cur) ||
+            (a.name && a.name.toLowerCase().trim() === cur);
+    };
+    const qLower = (query || '').toLowerCase().trim();
+    const queryTokens = specificQueryTokens(query);
+    const allQueryWords = qLower.split(/[^a-z0-9]+/).filter((w) => w.length >= 3 && !GENERIC_QUERY_TOKENS.has(w));
+    const queryDomainWords = allQueryWords.filter(w => !CROSS_CUTTING_MODIFIERS.has(w));
+    const isBrandOrCorporateQuery = Boolean(options?.isBrandTracker ||
+        /brand|financial|earnings|corporate|cmo|ceo|cfo|executive|revenue|margin|quarterly|investor|q[1-4]|balance sheet/i.test(qLower));
+    const isPhilosophicalQuery = /art\b|aesthetic|philosophy|philosophical|criticism|craftsmanship|harlem renaissance|aesthetic theory|ethics of art|ruskin|locke\b/i.test(qLower);
+    function getCategory(a) {
+        if (a.category)
+            return a.category;
+        if (a.is_human_agent || a.is_verified_real_person)
+            return 'human_agent';
+        if (a.is_c_suite_agent || /brand-(cmo|ceo|cfo)/i.test(a.analyst_id || ''))
+            return 'c_suite_agent';
+        if (a.is_classic_agent)
+            return 'classic_agent';
+        const sub = (a.graphSubType || a.graph_sub_type || a.type || a.kind || '').toString().toLowerCase();
+        if (sub.includes('classic'))
+            return 'classic_agent';
+        if (sub.includes('digital twin') || sub.includes('human'))
+            return 'human_agent';
+        if (sub.includes('c-suite') || sub.includes('executive'))
+            return 'c_suite_agent';
+        return 'synthetic_agent';
+    }
+    const searchedGraphs = options?.searchedGraphs || (options?.graphs ? options.graphs : getRelevantGraphs(query, 4, 15, 0.10));
+    const rowsByGraph = options?.rowsByGraph || new Map();
+    const scoredAnalysts = [];
+    for (const a of activeAnalysts) {
+        if (isCurrentAnalyst(a))
+            continue;
+        let baseScore = 0;
+        let directMatch = false;
+        let hasExplicitMatch = false;
+        const category = getCategory(a);
+        // Extract expert name and slug parts for direct identification and blindspot immunity
+        const aName = (a.name || '').toLowerCase().trim();
+        const aSlug = (a.analyst_id || '').toLowerCase().trim();
+        const nameParts = new Set([
+            ...aName.split(/\s+/).filter((p) => p.length >= 3),
+            ...aSlug.split(/[-_]+/).filter((p) => p.length >= 3)
+        ]);
+        // 1. Negative signal: Blind spot / outside_their_lane
+        const rawBlindSpots = [
+            ...(Array.isArray(a.outside_their_lane) ? a.outside_their_lane : (typeof a.outside_their_lane === 'string' ? [a.outside_their_lane] : [])),
+            ...(Array.isArray(a.blind_spots) ? a.blind_spots : (typeof a.blind_spots === 'string' ? [a.blind_spots] : [])),
+        ].join(' ').toLowerCase();
+        let hasBlindSpot = false;
+        if (rawBlindSpots.length > 0) {
+            for (const t of queryTokens) {
+                if (nameParts.has(t))
+                    continue; // Never disqualify an expert for matching their own name or slug!
+                if (t.length >= 3 && rawBlindSpots.includes(t)) {
+                    hasBlindSpot = true;
+                    baseScore -= 20;
+                }
+            }
+            for (const w of allQueryWords) {
+                if (nameParts.has(w))
+                    continue; // Never disqualify an expert for matching their own name or slug!
+                if (w.length >= 4 && rawBlindSpots.includes(w)) {
+                    hasBlindSpot = true;
+                    baseScore -= 10;
+                }
+            }
+        }
+        // 2. Positive signal: expert_in & what_they_offer
+        const expertIn = [
+            ...(Array.isArray(a.expert_in) ? a.expert_in : (typeof a.expert_in === 'string' ? [a.expert_in] : [])),
+            ...(Array.isArray(a.what_they_offer) ? a.what_they_offer : (typeof a.what_they_offer === 'string' ? [a.what_they_offer] : [])),
+        ].join(' ').toLowerCase();
+        if (expertIn.length > 0) {
+            if (qLower.length > 5 && expertIn.includes(qLower)) {
+                baseScore += 8;
+                hasExplicitMatch = true;
+            }
+            for (const t of queryTokens) {
+                if (expertIn.includes(t)) {
+                    const isDomainToken = queryDomainWords.length === 0 || queryDomainWords.includes(t) || !CROSS_CUTTING_MODIFIERS.has(t);
+                    baseScore += isDomainToken ? 4 : 1.5;
+                    if (t.length >= 4 && isDomainToken)
+                        hasExplicitMatch = true;
+                }
+            }
+            for (const w of allQueryWords) {
+                if (expertIn.includes(w)) {
+                    const isDomainWord = queryDomainWords.length === 0 || queryDomainWords.includes(w) || !CROSS_CUTTING_MODIFIERS.has(w);
+                    baseScore += isDomainWord ? 1.5 : 0.5;
+                    if (w.length >= 4 && isDomainWord)
+                        hasExplicitMatch = true;
+                }
+            }
+        }
+        // 2b. Positive signal: direct name or analyst_id match (for lookup/booking/hiring intent)
+        if (qLower.includes(aName) && aName.length >= 4) {
+            baseScore += 15;
+            hasExplicitMatch = true;
+            directMatch = true;
+        }
+        else if (aSlug && (qLower.includes(aSlug) || aSlug.includes(qLower))) {
+            baseScore += 15;
+            hasExplicitMatch = true;
+            directMatch = true;
+        }
+        else {
+            for (const part of nameParts) {
+                if (queryTokens.includes(part) || allQueryWords.includes(part)) {
+                    baseScore += 10;
+                    hasExplicitMatch = true;
+                    directMatch = true;
+                    break;
+                }
+            }
+        }
+        // 3. Positive signal: topics
+        const aTopics = (Array.isArray(a.topics) ? a.topics : []).map((t) => (typeof t === 'string' ? t.toLowerCase() : '')).filter(Boolean);
+        for (const tp of aTopics) {
+            if (qLower.includes(tp) || tp.includes(qLower)) {
+                baseScore += 5;
+                hasExplicitMatch = true;
+            }
+            for (const t of queryTokens) {
+                if (tp.includes(t) || t.includes(tp)) {
+                    const isDomainToken = queryDomainWords.length === 0 || queryDomainWords.includes(t) || !CROSS_CUTTING_MODIFIERS.has(t);
+                    baseScore += isDomainToken ? 3 : 1;
+                    if (t.length >= 3 && tp.length >= 3 && isDomainToken)
+                        hasExplicitMatch = true;
+                }
+            }
+            for (const w of allQueryWords) {
+                if (tp.includes(w) || w.includes(tp)) {
+                    const isDomainWord = queryDomainWords.length === 0 || queryDomainWords.includes(w) || !CROSS_CUTTING_MODIFIERS.has(w);
+                    baseScore += isDomainWord ? 1.5 : 0.5;
+                    if (w.length >= 3 && tp.length >= 3 && isDomainWord)
+                        hasExplicitMatch = true;
+                }
+            }
+        }
+        // 4. Positive signal: description (supporting context)
+        const desc = (typeof a.description === 'string' ? a.description : '').toLowerCase();
+        if (desc.length > 0) {
+            if (qLower.length > 5 && desc.includes(qLower)) {
+                baseScore += 4;
+            }
+            for (const t of queryTokens) {
+                if (desc.includes(t)) {
+                    baseScore += 2;
+                }
+            }
+            for (const w of allQueryWords) {
+                if (desc.includes(w)) {
+                    baseScore += 1;
+                }
+            }
+        }
+        // 5. Positive signal: Searched graphs & graph relevance scores
+        for (const g of searchedGraphs) {
+            const gid = (typeof g === 'string' ? g : (g.graph_id || g.id || '')).toLowerCase().trim();
+            const gCurator = (typeof g === 'object' && g.curator ? g.curator : '').toLowerCase().trim();
+            const isOwner = (gid && (gid === aSlug || gid.includes(aSlug) || aSlug.includes(gid))) ||
+                (gCurator && (gCurator === aName || gCurator.includes(aName) || aName.includes(gCurator)));
+            if (isOwner) {
+                // If graph has a router relevance score, use it directly.
+                // If unscored (e.g. broadcast or unranked search), award positive score ONLY if
+                // this graph actually returned matching results in rowsByGraph.
+                const rowsForGraph = rowsByGraph.get(gid) || (aSlug ? rowsByGraph.get(aSlug) : null) || [];
+                const relScore = (typeof g === 'object' && typeof g.relevanceScore === 'number')
+                    ? g.relevanceScore
+                    : (rowsForGraph.length > 0 ? 0.8 : 0);
+                if (relScore > 0) {
+                    baseScore += relScore * 5.0;
+                    hasExplicitMatch = true;
+                    if (relScore >= 0.5)
+                        directMatch = true;
+                }
+            }
+        }
+        let score = baseScore;
+        // ── Tier Intent Weighting ──
+        // Require base token relevance score >= 6 before applying any status preference boost
+        // so irrelevant profiles (sam-horn, taxtalk-online) are excluded on local fallback.
+        if (baseScore >= 6) {
+            if (category === 'c_suite_agent') {
+                if (isBrandOrCorporateQuery) {
+                    score += 6.0;
+                }
+                else {
+                    score -= 5.0;
+                }
+            }
+            else if (category === 'classic_agent') {
+                if (isPhilosophicalQuery) {
+                    score += 5.0;
+                }
+                else {
+                    score -= 10.0; // Classic thinkers must never outrank living practitioners on contemporary queries
+                }
+            }
+            else if (category === 'human_agent' || a.is_verified_real_person) {
+                score += 3.0; // Prioritize living human practitioners over synthetic agents
+            }
+        }
+        scoredAnalysts.push({ analyst: a, score, hasBlindSpot, hasExplicitMatch, directMatch });
+    }
+    // Require minimum threshold score (>= 6.0), explicit domain/topic match, and no disqualifying blind spot match
+    const MIN_EXPERT_FIT_SCORE = 6.0;
+    const validCandidates = scoredAnalysts
+        .filter(s => s.score >= MIN_EXPERT_FIT_SCORE && (s.directMatch || (s.hasExplicitMatch && !s.hasBlindSpot)))
+        .sort((a, b) => b.score - a.score);
+    const maxLimit = Math.min(Math.max(options?.limit || 3, 1), 3);
+    const topCandidates = validCandidates.slice(0, maxLimit);
+    const status = options?.status;
+    return topCandidates.map(c => {
+        const matchedAnalyst = c.analyst;
+        let lane = '';
+        const expertInStr = Array.isArray(matchedAnalyst.expert_in)
+            ? matchedAnalyst.expert_in.filter(Boolean).join(', ')
+            : (typeof matchedAnalyst.expert_in === 'string' ? matchedAnalyst.expert_in : '');
+        if (expertInStr.trim().length > 0) {
+            lane = truncateAtWordBoundary(expertInStr.trim(), 60);
+        }
+        else if (matchedAnalyst.description && matchedAnalyst.description.trim().length > 0) {
+            const firstClause = (matchedAnalyst.description.split(/[,.;]/)[0] || '').trim();
+            lane = truncateAtWordBoundary(firstClause, 60);
+        }
+        else if (matchedAnalyst.what_they_offer && typeof matchedAnalyst.what_they_offer === 'string' && matchedAnalyst.what_they_offer.trim().length > 0) {
+            lane = truncateAtWordBoundary(matchedAnalyst.what_they_offer.trim(), 60);
+        }
+        const reason = (status === 'thin' || status === 'empty')
+            ? (lane && lane.length > 3 ? `closest expert lane for ${lane}` : 'closest expert lane for this topic')
+            : (lane && lane.length > 3 ? `covers ${lane} directly` : 'covers this domain directly');
+        const cat = matchedAnalyst.category || getCategory(matchedAnalyst);
+        const statusRaw = (matchedAnalyst.status || matchedAnalyst.Status || '').toLowerCase().trim();
+        const isOnRequest = statusRaw === 'unclaimed' || statusRaw === 'on request' || statusRaw === 'on_request';
+        const expertStatus = isOnRequest ? 'on_request' : 'active';
+        const consult_tool = (matchedAnalyst.consult_tool === 'consult_human_agent' || matchedAnalyst.consult_tool === 'consult_analyst')
+            ? matchedAnalyst.consult_tool
+            : (cat === 'human_agent' ? 'consult_human_agent' : 'consult_analyst');
+        return {
+            analyst_id: matchedAnalyst.analyst_id,
+            display_name: cleanDisplayName(matchedAnalyst.name),
+            category: cat,
+            status: expertStatus,
+            consult_tool,
+            reason,
+            out_of_lane: false
+        };
+    });
+}
+export async function generateNextMoves(rows, query, searchedGraphs, status, onTopicCount, suggestedAction, catalog = getGraphs(), analysts = getAnalysts(), options) {
     const nextMoves = {
         scope_prompt: true,
         presentation: 'internal',
@@ -530,97 +1145,102 @@ export function generateNextMoves(rows, query, searchedGraphs, status, onTopicCo
             }
         }
         else {
-            // Empty brand footprint: pick top domain graph from catalog without keyword-matching on bare brand name
-            const domainGraphs = catalog.filter(g => g.graph_type === 'domain' || !g.curator);
-            const topDomain = domainGraphs[0] || catalog[0];
-            if (topDomain) {
-                const topDisplay = buildDisplayName(topDomain);
+            // Empty brand footprint: try to find relevant unsearched domain graph if score >= 0.10
+            let relevantCandidates = [];
+            try {
+                relevantCandidates = getRelevantGraphs(query);
+            }
+            catch {
+                relevantCandidates = [];
+            }
+            const unsearchedDomain = relevantCandidates.find(cand => cand.graph && !searchedGraphIds.has(cand.graph.graph_id) && (cand.score ?? 0) >= 0.10)?.graph;
+            const primarySearched = searchedGraphs[0];
+            const primaryGid = typeof primarySearched === 'string' ? primarySearched : primarySearched?.graph_id;
+            const primaryMeta = catalog.find(g => g.graph_id === primaryGid);
+            const primaryDisplay = primaryMeta ? buildDisplayName(primaryMeta) : (primaryGid || 'the graph');
+            if (unsearchedDomain) {
+                const topDisplay = buildDisplayName(unsearchedDomain);
                 nextMoves.thread = {
                     kind: 'honest_thin',
-                    graph_id: topDomain.graph_id,
-                    graph_display: topDisplay,
+                    graph_id: primaryGid || unsearchedDomain.graph_id,
+                    graph_display: primaryDisplay,
                     adjacent: {
-                        graph_id: topDomain.graph_id,
+                        graph_id: unsearchedDomain.graph_id,
                         graph_display: topDisplay,
-                        reason: topDomain.headline || topDomain.domain || topDomain.name,
+                        reason: unsearchedDomain.headline || unsearchedDomain.domain || unsearchedDomain.name,
                     }
                 };
             }
+            else {
+                nextMoves.thread = {
+                    kind: 'honest_thin',
+                    graph_id: primaryGid,
+                    graph_display: primaryDisplay,
+                    text: `That's what Fodda holds on this right now.`,
+                };
+            }
         }
     }
-    else if (maxRemainder > 0 && bestGraphId) {
-        const gMeta = catalog.find(g => g.graph_id === bestGraphId);
-        const display = gMeta ? buildDisplayName(gMeta) : bestGraphId;
-        nextMoves.thread = {
-            kind: 'more_in_graph',
-            graph_id: bestGraphId,
-            graph_display: display,
-            remaining_count: maxRemainder,
-            theme: bestGraphTheme,
-        };
-    }
-    else if (status === 'thin' || status === 'empty') {
-        // honest_thin ONLY when status is thin or empty
-        let relevantCandidates = [];
-        try {
-            relevantCandidates = getRelevantGraphs(query);
-        }
-        catch {
-            relevantCandidates = [];
-        }
-        const candidateGraphs = relevantCandidates.map(c => c.graph).filter(Boolean);
-        if (candidateGraphs.length === 0 && catalog?.length > 0) {
-            candidateGraphs.push(...catalog);
-        }
-        const closest = candidateGraphs.find(g => !searchedGraphIds.has(g.graph_id)) || candidateGraphs[0];
-        if (closest) {
-            const closestDisplay = buildDisplayName(closest);
-            const primarySearched = searchedGraphs[0];
-            const primaryGid = typeof primarySearched === 'string' ? primarySearched : primarySearched?.graph_id;
-            const primaryMeta = catalog.find(g => g.graph_id === primaryGid);
-            const primaryDisplay = primaryMeta ? buildDisplayName(primaryMeta) : (primaryGid || closestDisplay);
+    else {
+        const bestMeta = bestGraphId ? catalog.find(g => g.graph_id === bestGraphId) : undefined;
+        const trendCount = bestMeta?.trend_count;
+        const gOnTopicTotal = bestGraphId
+            ? (rowsByGraph.get(bestGraphId)?.[0]?.on_topic_total ?? options?.onTopicTotal ?? (maxRemainder + rows.length))
+            : undefined;
+        const isSmallReportOrExhausted = (typeof trendCount === 'number' && trendCount > 0 && trendCount <= 15) ||
+            (typeof trendCount === 'number' && trendCount > 0 && typeof gOnTopicTotal === 'number' && gOnTopicTotal >= 0.6 * trendCount);
+        const canEmitMoreInGraph = maxRemainder > 0 && bestGraphId && !isSmallReportOrExhausted;
+        if (canEmitMoreInGraph && bestGraphId) {
+            const display = bestMeta ? buildDisplayName(bestMeta) : bestGraphId;
             nextMoves.thread = {
-                kind: 'honest_thin',
-                graph_id: primaryGid || closest.graph_id,
-                graph_display: primaryDisplay,
-                adjacent: {
-                    graph_id: closest.graph_id,
-                    graph_display: closestDisplay,
-                    reason: closest.headline || closest.domain || closest.name,
-                }
+                kind: 'more_in_graph',
+                graph_id: bestGraphId,
+                graph_display: display,
+                remaining_count: maxRemainder,
+                theme: bestGraphTheme,
             };
         }
-        // If no candidate exists, thread is undefined (no fabrication)
-    }
-    else {
-        // status is 'ok' with 0 remainder everywhere: check for unsearched adjacent room
-        let relevantCandidates = [];
-        try {
-            relevantCandidates = getRelevantGraphs(query);
-        }
-        catch {
-            relevantCandidates = [];
-        }
-        const unsearched = relevantCandidates.find(cand => cand.graph && !searchedGraphIds.has(cand.graph.graph_id) && (cand.score ?? 0) >= 0.10);
-        if (unsearched) {
-            const adjG = unsearched.graph;
-            const adjDisplay = buildDisplayName(adjG);
+        else {
+            // Fall through to unsearched adjacent_room or honest_thin
+            let relevantCandidates = [];
+            try {
+                relevantCandidates = getRelevantGraphs(query);
+            }
+            catch {
+                relevantCandidates = [];
+            }
+            const unsearchedCandidate = relevantCandidates.find(cand => cand.graph && !searchedGraphIds.has(cand.graph.graph_id) && (cand.score ?? 0) >= 0.10);
             const primarySearched = searchedGraphs[0];
             const primaryGid = typeof primarySearched === 'string' ? primarySearched : primarySearched?.graph_id;
             const primaryMeta = catalog.find(g => g.graph_id === primaryGid);
-            const primaryDisplay = primaryMeta ? buildDisplayName(primaryMeta) : (primaryGid || adjDisplay);
-            nextMoves.thread = {
-                kind: 'adjacent_room',
-                graph_id: primaryGid || adjG.graph_id,
-                graph_display: primaryDisplay,
-                adjacent: {
-                    graph_id: adjG.graph_id,
-                    graph_display: adjDisplay,
-                    reason: adjG.headline || adjG.domain || adjG.description || adjG.name,
-                }
-            };
+            const primaryDisplay = primaryMeta ? buildDisplayName(primaryMeta) : (primaryGid || 'the graph');
+            if (unsearchedCandidate) {
+                const adjG = unsearchedCandidate.graph;
+                const adjDisplay = buildDisplayName(adjG);
+                nextMoves.thread = {
+                    kind: (status === 'thin' || status === 'empty' || isSmallReportOrExhausted) ? 'honest_thin' : 'adjacent_room',
+                    graph_id: primaryGid || adjG.graph_id,
+                    graph_display: primaryDisplay,
+                    adjacent: {
+                        graph_id: adjG.graph_id,
+                        graph_display: adjDisplay,
+                        reason: adjG.headline || adjG.domain || adjG.description || adjG.name,
+                    }
+                };
+            }
+            else if (status === 'thin' || status === 'empty' || isSmallReportOrExhausted) {
+                // Honest thin without hallucinated adjacent graph: never fabricate catalog[0] or blind unsearched fallback
+                nextMoves.thread = {
+                    kind: 'honest_thin',
+                    graph_id: primaryGid,
+                    graph_display: primaryDisplay,
+                    text: `That's what Fodda holds on this right now.`,
+                };
+            }
+            else {
+                nextMoves.thread = undefined;
+            }
         }
-        // If no unsearched relevant room, thread is undefined (drop the line, no fabrication)
     }
     // ── 2. Specific (Go specific: brands, statistics_source, expert) ──
     const specific = {};
@@ -635,39 +1255,61 @@ export function generateNextMoves(rows, query, searchedGraphs, status, onTopicCo
     else {
         const tokens = specificQueryTokens(query);
         const onTopicRows = rows.filter(r => rowMatchesQueryTokens(r, tokens, catalog) || (rowScore(r) >= 0.75 * (TIER_NOMINAL_SCORE[resolveRowTier(r, searchedGraphs, catalog)] ?? 0.8)));
-        const brandSourceRows = onTopicRows.length > 0 ? onTopicRows : rows;
-        const brandCounts = new Map();
-        for (const r of brandSourceRows) {
-            const brandList = [];
-            if (Array.isArray(r.brandNames))
-                brandList.push(...r.brandNames);
-            if (Array.isArray(r.brands))
-                brandList.push(...r.brands);
-            if (typeof r.brand === 'string' && r.brand)
-                brandList.push(r.brand);
-            if (typeof r.company === 'string' && r.company)
-                brandList.push(r.company);
-            if (Array.isArray(r.entities?.brands))
-                brandList.push(...r.entities.brands);
-            for (const b of brandList) {
-                if (typeof b === 'string' && b.trim().length > 1) {
-                    const cleaned = b.trim();
-                    brandCounts.set(cleaned, (brandCounts.get(cleaned) || 0) + 1);
+        // If no on-topic rows exist, leave specific.brands undefined (do not fall back to off-topic noise rows)
+        if (onTopicRows.length > 0) {
+            const publisherTokens = buildPublisherExclusionSet(searchedGraphs, catalog, onTopicRows);
+            const brandCounts = new Map();
+            for (const r of onTopicRows) {
+                if (!isRowBrandEligible(r))
+                    continue;
+                const brandList = [];
+                if (Array.isArray(r.brandNames))
+                    brandList.push(...r.brandNames);
+                else if (typeof r.brandNames === 'string')
+                    brandList.push(...r.brandNames.split('|'));
+                if (Array.isArray(r.brands))
+                    brandList.push(...r.brands);
+                if (typeof r.brand === 'string' && r.brand)
+                    brandList.push(r.brand);
+                if (typeof r.Brand === 'string' && r.Brand)
+                    brandList.push(...r.Brand.split('|'));
+                else if (Array.isArray(r.Brand))
+                    brandList.push(...r.Brand);
+                if (typeof r.company === 'string' && r.company)
+                    brandList.push(r.company);
+                if (Array.isArray(r.entities?.brands))
+                    brandList.push(...r.entities.brands);
+                for (const b of brandList) {
+                    if (typeof b === 'string' && b.trim().length > 1) {
+                        const clean = b.trim();
+                        const norm = normalizeBrandKey(clean);
+                        if (!norm)
+                            continue;
+                        if (isPublisherBrand(clean, publisherTokens))
+                            continue;
+                        const existing = brandCounts.get(norm);
+                        if (existing) {
+                            existing.count++;
+                        }
+                        else {
+                            brandCounts.set(norm, { count: 1, displayName: clean });
+                        }
+                    }
                 }
             }
-        }
-        if (brandCounts.size > 0) {
-            const sortedBrands = [...brandCounts.entries()]
-                .filter(([b]) => {
-                const bLow = b.toLowerCase();
+            if (brandCounts.size > 0) {
                 const qLow = query.toLowerCase();
-                return bLow !== qLow && !qLow.includes(bLow) && !bLow.includes(qLow);
-            })
-                .sort((a, b) => b[1] - a[1])
-                .map(([brand]) => brand)
-                .slice(0, 2);
-            if (sortedBrands.length > 0) {
-                specific.brands = sortedBrands;
+                const sortedBrands = [...brandCounts.values()]
+                    .filter(b => {
+                    const bLow = b.displayName.toLowerCase();
+                    return bLow !== qLow && !qLow.includes(bLow) && !bLow.includes(qLow);
+                })
+                    .sort((a, b) => b.count - a.count)
+                    .map(b => b.displayName)
+                    .slice(0, 2);
+                if (sortedBrands.length > 0) {
+                    specific.brands = sortedBrands;
+                }
             }
         }
     }
@@ -699,65 +1341,155 @@ export function generateNextMoves(rows, query, searchedGraphs, status, onTopicCo
     else {
         const qLower = query.toLowerCase();
         const isStatOrMarketShaped = suggestedAction !== undefined ||
+            status === 'thin' ||
+            status === 'empty' ||
             isDemandShaped(query) ||
             options?.knownBrand !== undefined ||
             (specific.brands && specific.brands.length > 0) ||
             /(?:market|spend|sales|growth|size|volume|rate|adoption|share|stats?|numbers?|forecast|demographics?|economic|inflation|pricing|consumer|retail|cpg|beauty|fashion|auto|tech|work|travel|food|drink|beverage|culture|trends?|brand|performance|activity)/i.test(qLower);
         if (isStatOrMarketShaped) {
-            if (/(?:retail|spend|sales|commerce|shopping|store|grocery|cpg|consumer)/i.test(qLower)) {
-                specific.statistics_source = 'Census retail trade and spending data';
-            }
-            else if (/(?:search|demand|interest|popular|google|volume|buzz|social)/i.test(qLower)) {
-                specific.statistics_source = 'Google Trends search volume and breakout queries';
-            }
-            else if (/(?:employment|labor|job|wage|worker|workplace|talent|hiring)/i.test(qLower)) {
-                specific.statistics_source = 'BLS labor and employment metrics';
-            }
-            else if (/(?:economic|inflation|cpi|interest\s+rate|gdp|macro|fed|recession)/i.test(qLower)) {
-                specific.statistics_source = 'FRED macroeconomic series';
-            }
-            else if (/(?:beauty|fashion|apparel|luxury|sport|wellness|food|beverage)/i.test(qLower)) {
-                specific.statistics_source = 'Census and Google Trends market demand data';
+            let suggestHandled = false;
+            if (options?.foddaRequest || options?.suggestFn || options?.suggestPromise) {
+                const sources = await fetchSupplementalSuggest(query, options);
+                if (sources && sources.length > 0) {
+                    const validSources = sources.filter(s => s && s.returns_draft !== true && s.name);
+                    if (validSources.length > 0) {
+                        const topSources = validSources.slice(0, 2);
+                        if (topSources.length === 2 && topSources[0] && topSources[1]) {
+                            specific.statistics_source = `${topSources[0].name} and ${topSources[1].name}`;
+                        }
+                        else if (topSources[0]) {
+                            specific.statistics_source = topSources[0].name;
+                        }
+                        suggestHandled = true;
+                        options?.sessionTracker?.recordSuggestPath?.('suggest');
+                        console.error(`[next_moves] statistics_source from suggest: "${specific.statistics_source}"`);
+                    }
+                }
             }
-            else {
-                specific.statistics_source = 'Census and FRED market statistics';
+            if (!suggestHandled) {
+                options?.sessionTracker?.recordSuggestPath?.('regex-fallback');
+                console.error(`[next_moves] statistics_source from regex-fallback`);
+                if (/(?:retail|spend|sales|commerce|shopping|store|grocery|cpg|consumer)/i.test(qLower)) {
+                    specific.statistics_source = 'Census retail trade and spending data';
+                }
+                else if (/(?:search|demand|interest|popular|google|volume|buzz|social)/i.test(qLower)) {
+                    specific.statistics_source = 'Google Trends search volume and breakout queries';
+                }
+                else if (/(?:employment|labor|job|wage|worker|workplace|talent|hiring)/i.test(qLower)) {
+                    specific.statistics_source = 'BLS labor and employment metrics';
+                }
+                else if (/(?:economic|inflation|cpi|interest\s+rate|gdp|macro|fed|recession)/i.test(qLower)) {
+                    specific.statistics_source = 'FRED macroeconomic series';
+                }
+                else if (/(?:beauty|fashion|apparel|luxury|sport|wellness|food|beverage)/i.test(qLower)) {
+                    specific.statistics_source = 'Census and Google Trends market demand data';
+                }
+                else {
+                    specific.statistics_source = 'Census and FRED market statistics';
+                }
             }
         }
     }
-    // Expert: first Active analyst whose graph was searched or scored >= threshold in routing
-    const activeAnalysts = analysts.filter(a => {
-        const st = (a.status || a.Status || '').toLowerCase().trim();
-        return !st || st === 'active';
-    });
-    const isCurrentAnalyst = (a) => {
-        if (!options?.currentAnalystId)
-            return false;
-        const cur = options.currentAnalystId.toLowerCase().trim();
-        return (a.analyst_id && a.analyst_id.toLowerCase().trim() === cur) ||
-            (a.name && a.name.toLowerCase().trim() === cur);
-    };
-    const matchedAnalyst = activeAnalysts.find(a => {
-        if (isCurrentAnalyst(a))
-            return false;
-        const aSlug = (a.analyst_id || '').toLowerCase().trim();
-        if (searchedGraphIds.has(aSlug))
-            return true;
-        const aName = (a.name || '').toLowerCase();
-        const aDesc = (a.description || '').toLowerCase();
-        if (tokens.some(t => aName.includes(t) || aDesc.includes(t)))
-            return true;
-        return false;
+    // Expert: scored lane-fit picker over active analysts using shared findCandidateExperts
+    const candidateExperts = findCandidateExperts(query, {
+        analysts,
+        graphs: catalog,
+        limit: 1,
+        currentAnalystId: options?.currentAnalystId,
+        searchedGraphs,
+        rowsByGraph,
+        status,
+        isBrandTracker: options?.isBrandTracker
     });
-    if (matchedAnalyst) {
-        specific.expert = {
-            analyst_id: matchedAnalyst.analyst_id,
-            display_name: matchedAnalyst.name,
-            reason: matchedAnalyst.description ? `covers ${matchedAnalyst.description.slice(0, 50).trim()} directly` : 'covers this domain directly',
-        };
+    if (candidateExperts.length > 0 && candidateExperts[0]) {
+        specific.expert = candidateExperts[0];
     }
     if (Object.keys(specific).length > 0) {
         nextMoves.specific = specific;
     }
+    nextMoves.scope = options?.knownBrand
+        ? `Want this cut to ${options.knownBrand} specifically?`
+        : `If you tell me the brand or brief you're working on, I'll cut this to that.`;
+    const cleanTopic = options?.knownBrand || options?.brandDisplayName || nextMoves.thread?.theme || query.trim();
+    const isOnRequestExpert = specific.expert?.status === 'on_request';
+    const isExpertHuman = specific.expert?.category === 'human_agent' || specific.expert?.consult_tool === 'consult_human_agent';
+    let expertTargetTool = 'find_expert';
+    let expertName = 'Consult specialist';
+    let expertDescription = 'Get practitioner judgment and domain depth on this topic.';
+    let expertReason = 'Consult a domain specialist to interpret qualitative nuances.';
+    let expertPrompt = `Who should I consult about ${cleanTopic}?`;
+    let expertParams = { query: cleanTopic };
+    if (specific.expert) {
+        if (isOnRequestExpert) {
+            expertTargetTool = 'request_expert_intro';
+            expertName = `Request intro to ${specific.expert.display_name}`;
+            expertDescription = 'Request an advisory introduction or consultation with this prospective Human Agent.';
+            expertReason = `Connect with ${specific.expert.display_name} for human advisory or consultation.`;
+            expertPrompt = `Request an introduction or advisory consultation with ${specific.expert.display_name} regarding ${cleanTopic}.`;
+            expertParams = { expert_id: specific.expert.analyst_id, query: cleanTopic };
+        }
+        else if (isExpertHuman) {
+            expertTargetTool = 'consult_human_agent';
+            expertName = `Consult ${specific.expert.display_name}`;
+            expertDescription = 'Consult this verified Human Agent twin for practitioner depth and proprietary frameworks.';
+            expertReason = `Consult ${specific.expert.display_name} for authoritative interpretation and practitioner depth.`;
+            expertPrompt = `Ask ${specific.expert.display_name} about ${cleanTopic}`;
+            expertParams = { analyst_id: specific.expert.analyst_id, query: `How should we evaluate the strategic opportunity and risks in ${cleanTopic}?` };
+        }
+        else {
+            expertTargetTool = specific.expert.consult_tool || 'consult_analyst';
+            expertName = `Consult ${specific.expert.display_name}`;
+            expertDescription = 'Consult this specialist analyst for domain intelligence.';
+            expertReason = `Consult ${specific.expert.display_name} for authoritative interpretation and practitioner depth.`;
+            expertPrompt = `Ask ${specific.expert.display_name} about ${cleanTopic}`;
+            expertParams = { analyst_id: specific.expert.analyst_id, query: cleanTopic };
+        }
+    }
+    const actions = [
+        {
+            action: 'pressure_test',
+            name: 'Pressure-test thesis',
+            description: 'Evaluate assertions against counter-evidence and executive divergence.',
+            reason: 'Evaluate whether findings rely on untested assumptions',
+            target_tool: 'verify_market_claim',
+            tool_display_name: 'Market Claim Verifier',
+            suggested_prompt: `Pressure-test whether the market momentum around ${cleanTopic} holds up against counter-evidence.`,
+            suggested_parameters: { claim: `Pressure-test whether ${cleanTopic} strategy and market momentum holds up` },
+            available: true,
+        },
+        {
+            action: 'ask_expert',
+            name: expertName,
+            description: expertDescription,
+            reason: expertReason,
+            target_tool: expertTargetTool,
+            suggested_prompt: expertPrompt,
+            suggested_parameters: expertParams,
+            available: true,
+        },
+        {
+            action: 'create_brief',
+            name: 'Commission executive brief',
+            description: 'Turn this intelligence into a finished strategic deliverable.',
+            reason: `Package verified evidence, quantitative statistics, and executive quotes on ${cleanTopic} into a deliverable.`,
+            target_tool: 'request_deliverable',
+            suggested_prompt: `Commission an executive brief on ${cleanTopic}`,
+            suggested_parameters: { skill_slug: 'research_brief', brief: `Synthesize verified findings, market metrics, and strategic implications for ${cleanTopic}` },
+            available: true,
+        },
+        {
+            action: 'track_topic',
+            name: 'Track topic shifts',
+            description: 'Establish automated weekly monitoring on this subject.',
+            reason: `Detect newly emerging signals, shifts in executive tone, and trend momentum on ${cleanTopic} weekly.`,
+            target_tool: 'manage_scheduled_reports',
+            suggested_prompt: `Set up weekly tracking on ${cleanTopic}`,
+            suggested_parameters: { action: 'create', topic: cleanTopic, cadence: 'weekly' },
+            available: true,
+        },
+    ];
+    nextMoves.actions = actions;
     return nextMoves;
 }
 /**
@@ -828,13 +1560,16 @@ export function generateConsultNextMoves(result, query, analystId, options, cata
         }
     }
     else {
-        // Next angle token check per §2.A.5: must share >=1 content token (>=3 chars) with sources_used or uncited_themes
+        // Next angle token check per §2.A.5: must share >=1 content token (>=3 chars) with sources_used, uncited_themes, query, or expert topics
         let nextAngleValid = false;
         if (typeof nextAngleRaw === 'string' && nextAngleRaw.trim().length > 0) {
             const angleTokens = specificQueryTokens(nextAngleRaw);
-            const sourceTitles = (result?.sources_used || []).map((s) => (s.title || s.name || '').toLowerCase());
+            const sourceTitles = (result?.sources_used || [])
+                .filter((s) => s.origin !== 'profile' && !(s.title || '').includes('Official Profile'))
+                .map((s) => (s.title || s.name || '').toLowerCase());
             const themeTexts = uncitedThemes.map((t) => t.toLowerCase());
-            const groundingCorpus = [...sourceTitles, ...themeTexts].join(' ');
+            const expertTopics = Array.isArray(matchedAnalyst?.topics) ? matchedAnalyst.topics.join(' ').toLowerCase() : '';
+            const groundingCorpus = [...sourceTitles, ...themeTexts, expertTopics, query.toLowerCase()].join(' ');
             const hasSharedToken = angleTokens.some(tok => tok.length >= 3 && groundingCorpus.includes(tok));
             if (hasSharedToken || (sourceTitles.length === 0 && themeTexts.length === 0)) {
                 nextAngleValid = true;
@@ -905,7 +1640,8 @@ export function generateConsultNextMoves(result, query, analystId, options, cata
         if (matchedAnalyst.slug)
             expertOwnIds.add(String(matchedAnalyst.slug).toLowerCase());
     }
-    const SHELF_RELEVANCE_FLOOR = 0.10;
+    const SHELF_RELEVANCE_FLOOR = 0.50;
+    const queryTokens = specificQueryTokens(query);
     const shelfCandidateGraphs = [];
     for (const cand of relevantCandidates) {
         if ((cand.score ?? 0) < SHELF_RELEVANCE_FLOOR)
@@ -920,6 +1656,26 @@ export function generateConsultNextMoves(result, query, analystId, options, cata
             continue;
         if (g.name && g.name.toLowerCase() === expertDisplayName.toLowerCase())
             continue;
+        // Shelf on an expert consult must only suggest published research/trend graphs (report, domain),
+        // never other individual expert agents or classic historical figures.
+        const gType = (g.graph_type || '').toLowerCase();
+        if (gType === 'expert' || gType === 'analyst' || cand.graphTier === 'static_expert' || cand.graphTier === 'living') {
+            continue;
+        }
+        // Must match at least 2 distinct domain tokens from the query, or have a direct topic match
+        let tokenMatchCount = 0;
+        if (queryTokens.length > 0) {
+            const graphText = `${g.name || ''} ${g.domain || ''} ${(Array.isArray(g.topics) ? g.topics : []).join(' ')} ${g.headline || ''} ${g.one_liner || ''} ${g.description || ''}`.toLowerCase();
+            const words = new Set(graphText.split(/[^a-z0-9]+/));
+            for (const t of queryTokens) {
+                if (t.length >= 3 && words.has(t)) {
+                    tokenMatchCount++;
+                }
+            }
+        }
+        const minMatchesNeeded = queryTokens.length >= 2 ? 2 : 1;
+        if (tokenMatchCount < minMatchesNeeded)
+            continue;
         if (shelfCandidateGraphs.length < 2 && !shelfCandidateGraphs.some(sg => sg.graph_id === g.graph_id)) {
             shelfCandidateGraphs.push(g);
         }
@@ -948,8 +1704,12 @@ export function generateConsultNextMoves(result, query, analystId, options, cata
             shelfSentence += `.`;
         }
     }
+    else if (hasDeliverableOffering) {
+        shelfSentence = `${expertDisplayName} takes scoped briefs on this if you need a deliverable.`;
+        nextMoves.shelf = undefined;
+    }
     else {
-        // Empty candidate list — omit sentence 2 per Brief 1.46.29
+        // Empty candidate list and no deliverable offerings — omit sentence 2 per Brief 1.46.29
         shelfSentence = '';
         nextMoves.shelf = undefined;
     }
@@ -964,7 +1724,7 @@ export function generateConsultNextMoves(result, query, analystId, options, cata
         const topRef = result.referrals[0];
         specific.expert = {
             analyst_id: topRef.id || topRef.analyst_id || topRef.slug,
-            display_name: topRef.name || topRef.curator,
+            display_name: cleanDisplayName(topRef.name || topRef.curator),
             reason: topRef.reason || 'related expertise',
         };
     }
@@ -979,11 +1739,46 @@ export function generateConsultNextMoves(result, query, analystId, options, cata
     else {
         scopeSentence = `If you tell me the brand or brief you're working on, I'll cut this to that.`;
     }
+    nextMoves.scope = scopeSentence;
     nextMoves.consult_envelope = {
         thread_line: threadSentence,
         shelf_line: shelfSentence || undefined,
         scope_line: scopeSentence,
     };
+    const consultActions = [
+        {
+            action: 'pressure_test',
+            name: 'Pressure-test perspective',
+            description: "Verify expert assertions and claims against broader market data.",
+            reason: `Verify ${expertDisplayName}'s perspective against empirical market evidence and executive divergence.`,
+            target_tool: 'verify_market_claim',
+            tool_display_name: 'Market Claim Verifier',
+            suggested_prompt: `Pressure-test ${expertDisplayName}'s perspective on ${query.trim()}`,
+            suggested_parameters: { claim: `Pressure-test ${expertDisplayName}'s thesis and assertions on ${query.trim()}` },
+            available: true,
+        },
+        {
+            action: 'create_brief',
+            name: 'Commission deliverable',
+            description: `Commission a finished deliverable from ${expertDisplayName}.`,
+            reason: `Turn ${expertDisplayName}'s insights and framework into a formatted deliverable.`,
+            target_tool: 'request_deliverable',
+            suggested_prompt: `Commission a strategic briefing from ${expertDisplayName} on ${query.trim()}`,
+            suggested_parameters: { analyst_id: cleanAnalystId || expertGraphId, skill_slug: 'research_brief', brief: `Strategic brief incorporating ${expertDisplayName}'s framework on ${query.trim()}` },
+            available: true,
+        },
+        {
+            action: 'track_topic',
+            name: 'Track topic shifts',
+            description: 'Establish automated weekly monitoring on this subject.',
+            reason: `Monitor new signals and developments in ${expertDisplayName}'s coverage area.`,
+            target_tool: 'manage_scheduled_reports',
+            suggested_prompt: `Set up weekly tracking on ${query.trim()}`,
+            suggested_parameters: { action: 'create', topic: query.trim(), cadence: 'weekly' },
+            available: true,
+        },
+    ];
+    nextMoves.actions = consultActions;
     return nextMoves;
 }
 /**