myavana-bot-test-core 2.2.0 → 2.3.0

package/src/funnelEvents.js

@@ -0,0 +1,32 @@
+// funnelEvents.js
+const { pgClient } = require('./database');
+
+/**
+ * Logs a D2C conversion-funnel milestone (intake_completed, paywall_shown,
+ * purchase_completed, hhcp_delivered, consult_triaged, ...). Additive to
+ * conversation_metrics.conversion_event — lets funnel drop-off be queried per stage.
+ *
+ * @param {string} userId
+ * @param {string} conversationId
+ * @param {string} eventType
+ * @param {object} [metadata]
+ */
+const logFunnelEvent = async (userId, conversationId, eventType, metadata = {}) => {
+    const query = `
+        INSERT INTO chatbot_funnel_events (user_id, conversation_id, event_type, metadata)
+        VALUES ($1, $2, $3, $4)
+        RETURNING *;
+    `;
+    const values = [userId, conversationId, eventType, JSON.stringify(metadata)];
+    try {
+        const res = await pgClient.query(query, values);
+        return res.rows[0];
+    } catch (err) {
+        console.error('Error logging funnel event:', err);
+        return null;
+    }
+};
+
+module.exports = {
+    logFunnelEvent,
+};

package/src/messageContextBuilder.js

@@ -0,0 +1,84 @@
+// messageContextBuilder.js
+// Single injection point for all per-message dynamic context.
+// Order of blocks injected before each chat.send():
+//   1. Persona   — tone, style, trend framing instruction
+//   2. Trends    — what's currently popular in hair care (48h TTL)
+//   3. Driver    — what the AI should DO this turn (trend-aware)
+//   4. Memory    — durable facts/preferences relevant to the current message (Local Agent Memory)
+
+const { getUserPersona, buildContextBlock } = require('./personaClassifier');
+const { getConversationDirective, inferStage, extractTrendSummary } = require('./conversationDriver');
+const { getTrendContext } = require('./trendManager');
+const { retrieveRelevantMemories } = require('./agentMemory');
+
+/**
+ * Assembles the dynamic context block to prepend to each user message before chat.send().
+ * Returns an empty string when there is nothing to inject (first-time users, errors).
+ *
+ * @param {string} userId
+ * @param {Array<{role:string, content:string}>} [chatHistory=[]]
+ * @param {string} [currentMessage] - the message about to be sent; falls back to the last user turn in chatHistory
+ * @returns {Promise<string>}
+ */
+async function buildMessageContext(userId, chatHistory = [], currentMessage) {
+    const parts = [];
+
+    // Shared state — built up across steps so later steps can use earlier results
+    let personaType  = null;
+    let trendContext = '';
+
+    // 1. Persona context (tone + communication style)
+    //    Built first so trendFraming can be attached to persona block below
+    let persona = null;
+    try {
+        persona = await getUserPersona(userId);
+        if (persona) personaType = persona.personaType || null;
+    } catch (err) {
+        console.error('buildMessageContext: persona fetch failed:', err.message);
+    }
+
+    // 2. Trend context (what's trending — 48h cache, background refresh)
+    try {
+        const stage = inferStage(chatHistory);
+        trendContext = await getTrendContext(stage, personaType);
+    } catch (err) {
+        console.error('buildMessageContext: trend fetch failed:', err.message);
+    }
+
+    // Now build the persona block — hasTrends flag triggers trend framing instruction
+    if (persona) {
+        try {
+            const block = buildContextBlock(persona, trendContext.length > 0);
+            if (block) parts.push(block);
+        } catch (err) {
+            console.error('buildMessageContext: buildContextBlock failed:', err.message);
+        }
+    }
+
+    // Add trend block after persona
+    if (trendContext) parts.push(trendContext);
+
+    // 3. Conversation-driving directive (trend-aware, persona-aware)
+    try {
+        const trendSummary = extractTrendSummary(trendContext);
+        const directive = getConversationDirective(chatHistory, personaType, trendSummary);
+        if (directive) parts.push(directive);
+    } catch (err) {
+        console.error('buildMessageContext: conversation driver failed:', err.message);
+    }
+
+    // 4. Relevant long-term memory (Local Agent Memory — durable facts/preferences)
+    try {
+        const queryText = currentMessage || [...chatHistory].reverse().find(m => m.role === 'user')?.content;
+        const memories = await retrieveRelevantMemories(userId, queryText);
+        if (memories.length > 0) {
+            parts.push(`\nRelevant memory:\n${memories.map(m => `- ${m}`).join('\n')}\n`);
+        }
+    } catch (err) {
+        console.error('buildMessageContext: memory retrieval failed:', err.message);
+    }
+
+    return parts.join('');
+}
+
+module.exports = { buildMessageContext };

package/src/personaClassifier.js

@@ -0,0 +1,214 @@
+// personaClassifier.js
+const { pgClient, redisClient } = require('./database');
+
+const PERSONA_TYPES = {
+    OVERWHELMED:     'overwhelmed',     // stressed, multiple issues, needs reassurance
+    RESEARCHER:      'researcher',      // detail-oriented, wants science and data
+    EXPLORER:        'explorer',        // curious, open to experimenting, asks broad questions
+    ACTION_ORIENTED: 'action-oriented', // short messages, wants quick steps and no fluff
+    ENGAGED:         'engaged',         // high session depth, follows through on suggestions
+};
+
+const COMMUNICATION_STYLES = {
+    NURTURING:    'nurturing',    // warm, validating, patient
+    PROFESSIONAL: 'professional', // clear, structured, minimal filler
+    CASUAL:       'casual',       // friendly, relatable, light
+    CONCISE:      'concise',      // brief, direct, bullet points preferred
+};
+
+const REDIS_TTL = 60 * 60 * 24; // 24h
+
+/**
+ * Classifies user persona from post-processing signals and conversation patterns.
+ * Pure function — no I/O. Safe to call any time without side effects.
+ *
+ * @param {object} opts
+ * @param {object} opts.profileUpdates - Fields extracted by postProcessConversation
+ * @param {Array}  opts.chatHistory    - Full conversation history array
+ * @returns {{ personaType, communicationStyle, toneDirectives: string[] }}
+ */
+function classifyFromSignals({ profileUpdates = {}, chatHistory = [] }) {
+    const {
+        confidence_level_inferred,
+        desperation_level_inferred,
+        experimenting_interest,
+        boredom_expression,
+    } = profileUpdates;
+
+    const userMessages = chatHistory.filter(m => m.role === 'user');
+    const messageCount = userMessages.length;
+    const avgLength = messageCount > 0
+        ? userMessages.reduce((sum, m) => sum + (m.content?.length || 0), 0) / messageCount
+        : 0;
+
+    let personaType = PERSONA_TYPES.ENGAGED;
+    let communicationStyle = COMMUNICATION_STYLES.CASUAL;
+    const toneDirectives = [];
+
+    // Overwhelmed: high desperation or expressed low confidence
+    if (desperation_level_inferred === 'high' || confidence_level_inferred === 'low') {
+        personaType = PERSONA_TYPES.OVERWHELMED;
+        communicationStyle = COMMUNICATION_STYLES.NURTURING;
+        toneDirectives.push('lead with empathy before solutions');
+        toneDirectives.push('break advice into small, clear steps');
+        toneDirectives.push('avoid information overload — one thing at a time');
+    }
+    // Researcher: long detailed messages or self-reported high confidence
+    else if (avgLength > 200 || confidence_level_inferred === 'high') {
+        personaType = PERSONA_TYPES.RESEARCHER;
+        communicationStyle = COMMUNICATION_STYLES.PROFESSIONAL;
+        toneDirectives.push('skip basic explanations — treat them as a peer');
+        toneDirectives.push('include specific reasoning and science where relevant');
+        toneDirectives.push('precise language over reassuring language');
+    }
+    // Explorer: interested in experimenting, open to discovery
+    else if (experimenting_interest === true) {
+        personaType = PERSONA_TYPES.EXPLORER;
+        communicationStyle = COMMUNICATION_STYLES.CASUAL;
+        toneDirectives.push('encourage curiosity and experimentation');
+        toneDirectives.push('offer options rather than one prescriptive answer');
+        toneDirectives.push('frame suggestions as things worth trying');
+    }
+    // Action-oriented: short messages after multiple turns — wants speed
+    else if (avgLength < 60 && messageCount > 2) {
+        personaType = PERSONA_TYPES.ACTION_ORIENTED;
+        communicationStyle = COMMUNICATION_STYLES.CONCISE;
+        toneDirectives.push('lead with the answer — skip the preamble');
+        toneDirectives.push('use bullet points for multi-step advice');
+        toneDirectives.push('keep responses short and direct');
+    }
+
+    // Boredom modifier — user seems disengaged, regardless of persona
+    if (boredom_expression === true) {
+        toneDirectives.push('vary your approach — try an unexpected angle or a direct question');
+    }
+
+    return { personaType, communicationStyle, toneDirectives };
+}
+
+// How each persona should frame any trending topic that surfaces in the conversation.
+// Appended to persona directives when trends are present in context.
+const TREND_FRAMING = {
+    [COMMUNICATION_STYLES.NURTURING]:    'if a trend is relevant, offer it as one gentle option — do not overwhelm with choices',
+    [COMMUNICATION_STYLES.PROFESSIONAL]: 'when referencing trends, include the reason it works — evidence or mechanism, not just hype',
+    [COMMUNICATION_STYLES.CASUAL]:       'weave trending topics in naturally; frame them as exciting things worth trying',
+    [COMMUNICATION_STYLES.CONCISE]:      'state any relevant trend as a single quick tip — no backstory',
+};
+
+/**
+ * Builds the short context string to prepend to each user message.
+ * When hasTrends is true, appends a per-persona trend framing instruction.
+ *
+ * @param {{ personaType, communicationStyle, toneDirectives }} persona
+ * @param {boolean} [hasTrends=false] - Whether trend context is also being injected
+ * @returns {string}
+ */
+function buildContextBlock({ personaType, communicationStyle, toneDirectives = [] } = {}, hasTrends = false) {
+    if (!personaType) return '';
+
+    const allDirectives = [...toneDirectives];
+    if (hasTrends && communicationStyle && TREND_FRAMING[communicationStyle]) {
+        allDirectives.push(TREND_FRAMING[communicationStyle]);
+    }
+
+    const directives = allDirectives.length > 0 ? ` — ${allDirectives.join('; ')}` : '';
+    return `[User persona: ${personaType}, style: ${communicationStyle}${directives}]\n`;
+}
+
+/**
+ * Persists classified persona to user_preferences (upsert) and Redis.
+ * Non-throwing — persona save is best-effort, never blocks the response.
+ *
+ * @param {string} userId
+ * @param {{ personaType, communicationStyle, toneDirectives }} persona
+ */
+async function saveUserPersona(userId, { personaType, communicationStyle, toneDirectives }) {
+    try {
+        await pgClient.query(
+            `INSERT INTO user_preferences (user_id, persona_type, communication_style, engagement_preferences)
+             VALUES ($1, $2, $3, $4)
+             ON CONFLICT (user_id) DO UPDATE SET
+               persona_type          = EXCLUDED.persona_type,
+               communication_style   = EXCLUDED.communication_style,
+               engagement_preferences = EXCLUDED.engagement_preferences`,
+            [userId, personaType, communicationStyle, JSON.stringify({ toneDirectives })]
+        );
+    } catch (err) {
+        console.error('PersonaClassifier: PostgreSQL save failed:', err.message);
+    }
+
+    try {
+        if (redisClient) {
+            await redisClient.set(
+                `persona:${userId}`,
+                JSON.stringify({ personaType, communicationStyle, toneDirectives }),
+                { EX: REDIS_TTL }
+            );
+        }
+    } catch (err) {
+        console.error('PersonaClassifier: Redis save failed:', err.message);
+    }
+}
+
+/**
+ * Reads the saved persona for a user (Redis → PostgreSQL).
+ * Returns null if none has been saved yet.
+ *
+ * @param {string} userId
+ * @returns {Promise<{ personaType, communicationStyle, toneDirectives }|null>}
+ */
+async function getUserPersona(userId) {
+    try {
+        if (redisClient) {
+            const cached = await redisClient.get(`persona:${userId}`);
+            if (cached) return JSON.parse(cached);
+        }
+    } catch (err) {
+        console.error('PersonaClassifier: Redis read failed:', err.message);
+    }
+
+    try {
+        const result = await pgClient.query(
+            `SELECT persona_type, communication_style, engagement_preferences
+             FROM user_preferences WHERE user_id = $1`,
+            [userId]
+        );
+        if (result.rows.length > 0) {
+            const row = result.rows[0];
+            return {
+                personaType: row.persona_type,
+                communicationStyle: row.communication_style,
+                toneDirectives: row.engagement_preferences?.toneDirectives || [],
+            };
+        }
+    } catch (err) {
+        console.error('PersonaClassifier: PostgreSQL read failed:', err.message);
+    }
+
+    return null;
+}
+
+/**
+ * Full classification pipeline: classify from current signals, save to DB/Redis.
+ * Call this from postResponseProcessing after extracting profile signals.
+ *
+ * @param {string} userId
+ * @param {{ profileUpdates: object, chatHistory: Array }} opts
+ * @returns {Promise<{ personaType, communicationStyle, toneDirectives }>}
+ */
+async function classifyAndSavePersona(userId, { profileUpdates, chatHistory }) {
+    const persona = classifyFromSignals({ profileUpdates, chatHistory });
+    await saveUserPersona(userId, persona);
+    console.log(`🎭 Persona classified for ${userId}: ${persona.personaType} / ${persona.communicationStyle}`);
+    return persona;
+}
+
+module.exports = {
+    classifyFromSignals,
+    buildContextBlock,
+    saveUserPersona,
+    getUserPersona,
+    classifyAndSavePersona,
+    PERSONA_TYPES,
+    COMMUNICATION_STYLES,
+};

package/src/postResponseProcessing.js

@@ -6,6 +6,7 @@ const { pgClient, redisClient } = require('./database');
 const {generateAndSaveSummary, saveConversationSummary, saveConversation} = require("./conversation");
 const {saveHairIssue} = require("./hairIssues");
 const {getProductByName, addProductRecommendation} = require("./utils");
+const { classifyAndSavePersona } = require("./personaClassifier");
 
 const postProcessingPrompt = (chatHistory, message) => {
     return `
@@ -219,6 +220,14 @@ const processBotResponse = (botResponse) => {
     return processedResponse.trim(); // Remove trailing newline and whitespace
 };
 
+/**
+ * Uses Gemini to extract structured user profile updates and reported hair issues
+ * from the current conversation. Run non-blocking after sending the response.
+ *
+ * @param {Array<{role:string, content:string}>} chatHistory
+ * @param {string} message - User's latest message
+ * @returns {Promise<{user_profile_updates, hair_issue_extractions}>} Empty object on failure
+ */
 const postProcessConversation = async (chatHistory, message) => {
 
 
@@ -226,7 +235,7 @@ const postProcessConversation = async (chatHistory, message) => {
     //console.log('Extraction prompt: ', extractionPrompt);
     try {
         const chat = ai.chat({
-            model: googleAI.model('gemini-2.5-flash'),
+            model: googleAI.model('gemini-3.6-flash'),
             config: {
                 temperature: 1.1,
             },
@@ -314,12 +323,33 @@ const updateUserProfile = async (userId, updates) => {
     }
 };
 
+/**
+ * Persists all post-response data: profile updates, hair issues, product recommendations,
+ * and conversation history. Run non-blocking via setImmediate after sending the response.
+ *
+ * @param {{user_profile_updates, hair_issue_extractions}} postProcessData - Output of postProcessConversation()
+ * @param {string} userId
+ * @param {any} output - Raw AI output
+ * @param {string|null} allchatsSummary - Existing summary (skips generation if truthy)
+ * @param {string} conversationId
+ * @param {Array} chatHistory - Full history including latest turn
+ * @param {string} botMessage - JSON-stringified AI output (used for product check)
+ */
 const postResponseProcessing = async (postProcessData, userId, output, allchatsSummary, conversationId, chatHistory, botMessage )=>{
     if (postProcessData.user_profile_updates) {
-        //console.log("User profile updates to be applied:", postProcessData.user_profile_updates);
         await updateUserProfile(userId, postProcessData.user_profile_updates);
     }
 
+    // Classify and persist user persona from the latest signals — non-blocking, best-effort
+    try {
+        await classifyAndSavePersona(userId, {
+            profileUpdates: postProcessData.user_profile_updates || {},
+            chatHistory,
+        });
+    } catch (err) {
+        console.error('Persona classification failed (non-fatal):', err.message);
+    }
+
     if (postProcessData.hair_issue_extractions && postProcessData.hair_issue_extractions.hair_issues_reported && postProcessData.hair_issue_extractions.hair_issues_reported.length > 0) {
         for (const issue of postProcessData.hair_issue_extractions.hair_issues_reported) {
             await saveHairIssue(userId, issue, JSON.stringify(output)); // Or refine advice from output
@@ -385,7 +415,7 @@ const postResponseProductCheck = async (chatHistory, message) => {
     // Try Gemini first
     try {
         const chat = ai.chat({
-            model: googleAI.model('gemini-2.5-flash'),
+            model: googleAI.model('gemini-3.6-flash'),
             config: {
                 temperature: 0.3, // Reduced temperature for more consistent JSON formatting
             },

package/src/trendManager.js

@@ -0,0 +1,240 @@
+// trendManager.js
+// Keeps the AI aware of current hair, beauty, and wellness trends.
+//
+// Trends are AI-generated every 48h and stored in PostgreSQL.
+// Redis caches the current set for fast per-request reads.
+// Regeneration always runs in the background — it never blocks a response.
+//
+// Injection into conversation:
+//   buildMessageContext() calls getTrendContext(stage, personaType)
+//   which returns a short 1-line block like:
+//   "[Trending: scalp detoxing as foundation for growth; rice water protein rinses]\n"
+
+const { pgClient, redisClient } = require('./database');
+const ai = require('./ai');
+const { googleAI } = require('@genkit-ai/google-genai');
+const { z } = require('zod');
+
+const REDIS_KEY        = 'hair_trends:current';
+const REDIS_LOCK_KEY   = 'hair_trends:generating';
+const REDIS_CACHE_TTL  = 60 * 60 * 6;   // 6h Redis cache
+const TREND_MAX_AGE_MS = 48 * 60 * 60 * 1000; // 48h before DB trends are stale
+
+// ---------------------------------------------------------------------------
+// Trend generation (AI → DB)
+// ---------------------------------------------------------------------------
+
+const TREND_SCHEMA = z.object({
+    trends: z.array(z.object({
+        trend_name:       z.string(),
+        description:      z.string(),
+        category:         z.enum(['technique', 'ingredient', 'style', 'wellness']),
+        relevance_stages: z.array(z.number().int().min(1).max(8)),
+        trend_score:      z.number().min(0).max(1),
+    })),
+});
+
+const GENERATION_PROMPT = `
+You are a hair care industry analyst. Generate a list of exactly 10 hair care trends
+that are currently popular in 2025–2026 across social media, salons, and natural hair communities.
+
+Focus on trends relevant to textured, curly, and natural hair (4a, 4b, 4c, 3a–3c types).
+Include a mix of techniques, ingredients, styles, and wellness practices.
+
+For each trend:
+- trend_name: short name (3–6 words)
+- description: one sentence explaining what it is and why it works (max 20 words)
+- category: one of "technique" | "ingredient" | "style" | "wellness"
+- relevance_stages: array of Myavana journey stage numbers most relevant (1=Something New,
+  2=Rocking This, 3=Experimenting, 4=Boredom, 5=Desperation, 6=Damage/Protection,
+  7=Repair/Decision, 8=Hair Nirvana) — list 2–4 stages per trend
+- trend_score: float 0.0–1.0 indicating how hot this trend is right now
+
+Return ONLY a JSON object with a "trends" array. No markdown, no explanations.
+`;
+
+/**
+ * Checks whether the stored trends are older than TREND_MAX_AGE_MS.
+ * Returns true if trends need refreshing.
+ */
+async function isTrendsStale() {
+    try {
+        const result = await pgClient.query(
+            `SELECT MAX(generated_at) AS latest FROM hair_trends WHERE active = TRUE`
+        );
+        const latest = result.rows[0]?.latest;
+        if (!latest) return true;
+        return (Date.now() - new Date(latest).getTime()) > TREND_MAX_AGE_MS;
+    } catch {
+        return false; // if DB unavailable, don't trigger generation
+    }
+}
+
+/**
+ * AI-generates 10 trends and upserts them into the DB.
+ * Acquires a Redis lock to prevent concurrent generation.
+ * Safe to call concurrently — only one generation runs at a time.
+ */
+async function generateTrends() {
+    // Distributed lock — skip if another instance is already generating
+    try {
+        if (redisClient) {
+            const locked = await redisClient.set(REDIS_LOCK_KEY, '1', { NX: true, EX: 300 });
+            if (!locked) {
+                console.log('🌊 Trend generation already in progress (locked), skipping');
+                return;
+            }
+        }
+    } catch { /* Redis unavailable — proceed without lock */ }
+
+    try {
+        console.log('🌊 Generating fresh hair trends via AI...');
+
+        const result = await ai.generate({
+            model: googleAI.model('gemini-3.6-flash'),
+            output: { format: 'json', schema: TREND_SCHEMA },
+            config: { temperature: 0.7 },
+            prompt: GENERATION_PROMPT,
+        });
+
+        const { trends } = result.output;
+        if (!trends || !trends.length) {
+            console.warn('🌊 Trend generation returned empty — skipping DB write');
+            return;
+        }
+
+        // Expire existing AI-generated trends, insert new batch
+        await pgClient.query(
+            `UPDATE hair_trends SET active = FALSE WHERE source = 'ai-generated'`
+        );
+
+        for (const t of trends) {
+            await pgClient.query(
+                `INSERT INTO hair_trends
+                   (trend_name, description, category, relevance_stages, trend_score, source, active, generated_at, expires_at)
+                 VALUES ($1, $2, $3, $4, $5, 'ai-generated', TRUE, NOW(), NOW() + INTERVAL '48 hours')`,
+                [t.trend_name, t.description, t.category, t.relevance_stages, t.trend_score]
+            );
+        }
+
+        // Bust Redis cache so next read fetches fresh data
+        if (redisClient) {
+            await redisClient.del(REDIS_KEY).catch(() => {});
+        }
+
+        console.log(`🌊 ${trends.length} hair trends generated and saved`);
+    } catch (err) {
+        console.error('🌊 Trend generation failed:', err.message);
+    } finally {
+        if (redisClient) {
+            await redisClient.del(REDIS_LOCK_KEY).catch(() => {});
+        }
+    }
+}
+
+// ---------------------------------------------------------------------------
+// Trend retrieval
+// ---------------------------------------------------------------------------
+
+/**
+ * Fetches active trends from Redis (fast) → DB (fallback).
+ * Filters to trends relevant to the given stage; if none match, returns top by score.
+ *
+ * @param {number|null} stage     - Journey stage 1–8, or null
+ * @param {number}      limit     - Max trends to return
+ * @returns {Promise<Array>}
+ */
+async function getRelevantTrends(stage = null, limit = 3) {
+    // Try Redis first
+    try {
+        if (redisClient) {
+            const cached = await redisClient.get(REDIS_KEY);
+            if (cached) {
+                const all = JSON.parse(cached);
+                return selectTrends(all, stage, limit);
+            }
+        }
+    } catch { /* Redis miss — fall through to DB */ }
+
+    // DB fetch
+    try {
+        const result = await pgClient.query(
+            `SELECT trend_name, description, category, relevance_stages, trend_score
+             FROM hair_trends
+             WHERE active = TRUE AND expires_at > NOW()
+             ORDER BY trend_score DESC
+             LIMIT 20`
+        );
+
+        const trends = result.rows;
+
+        // Populate Redis for subsequent requests
+        if (trends.length > 0 && redisClient) {
+            await redisClient.set(REDIS_KEY, JSON.stringify(trends), { EX: REDIS_CACHE_TTL }).catch(() => {});
+        }
+
+        return selectTrends(trends, stage, limit);
+    } catch (err) {
+        console.error('trendManager: DB read failed:', err.message);
+        return [];
+    }
+}
+
+/**
+ * Selects the most relevant trends for the given stage.
+ * Stage-matched trends come first; remaining slots filled from top-scored.
+ */
+function selectTrends(allTrends, stage, limit) {
+    if (!allTrends.length) return [];
+
+    if (stage) {
+        const stageMatch = allTrends.filter(t =>
+            Array.isArray(t.relevance_stages) && t.relevance_stages.includes(stage)
+        );
+        const others = allTrends.filter(t =>
+            !Array.isArray(t.relevance_stages) || !t.relevance_stages.includes(stage)
+        );
+        return [...stageMatch, ...others].slice(0, limit);
+    }
+
+    return allTrends.slice(0, limit);
+}
+
+// ---------------------------------------------------------------------------
+// Context block builder
+// ---------------------------------------------------------------------------
+
+/**
+ * Builds the trend context string to inject into per-message context.
+ * Also triggers background refresh if trends are stale.
+ *
+ * @param {number|null} stage       - Inferred journey stage
+ * @param {string|null} personaType - From personaClassifier
+ * @returns {Promise<string>}
+ */
+async function getTrendContext(stage = null, personaType = null) {
+    // Kick off background refresh if stale — never awaited, never blocks
+    isTrendsStale().then(stale => {
+        if (stale) {
+            generateTrends().catch(err =>
+                console.error('trendManager: background refresh failed:', err.message)
+            );
+        }
+    }).catch(() => {});
+
+    const trends = await getRelevantTrends(stage, 2);
+    if (!trends.length) return '';
+
+    const names = trends.map(t => t.trend_name.toLowerCase()).join('; ');
+    return `[Trending in hair care: ${names}]\n`;
+}
+
+// ---------------------------------------------------------------------------
+
+module.exports = {
+    getTrendContext,
+    getRelevantTrends,
+    generateTrends,
+    isTrendsStale,
+    selectTrends, // exported for tests
+};

package/src/unifiedChatHandler.js

@@ -17,8 +17,8 @@ class UnifiedChatHandler {
         
         // Initialize model priority list - GEMINI FIRST!
         this.modelPriority = [
-            { name: 'gemini20FlashExp', model: googleAI.model('gemini-3-flash-preview'), type: 'primary' },
-            { name: 'gemini15Flash', model: googleAI.model('gemini-2.5-flash'), type: 'primary' },
+            { name: 'gemini20FlashExp', model: googleAI.model('gemini-3.7-flash'), type: 'primary' },
+            { name: 'gemini15Flash', model: googleAI.model('gemini-3.6-flash'), type: 'primary' },
             { name: 'gemini15Pro', model: googleAI.model('gemini-3-pro-preview'), type: 'backup' }
         ];