@semanticintent/semantic-chirp-intelligence-mcp 3.0.0

package/build/analyses/WeekendStreamAnalysis.js

@@ -0,0 +1,599 @@
+/**
+ * 🏒 Weekend Stream Analysis - Desperation vs Genuine Opportunity
+ *
+ * Distinguishes weekend streaming desperation (bye-week fillers, injury covers, <1-week value)
+ * from genuine opportunities (sustainable roles, >2-week upside, PP time, line jumps).
+ *
+ * Binary Classification Decision Tree:
+ * - Desperation: Context-driven (bye/injury), low floor, no role lock
+ * - Genuine: Independent catalysts, high ceiling, sustainable hold
+ * - Monitor: 50/50 territory, hot hand but risky matchup
+ *
+ * Upside Score Formula (0-100):
+ * Score = (0.30 * Proj FP/G * 10) + (0.30 * Opp TOI) + (0.20 * Schedule Ease) - (0.20 * Risk %)
+ * - >60 = Genuine opportunity
+ * - <40 = Desperation stream
+ *
+ * Semantic Identity: Weekend Stream Classifier
+ * Intent: I distinguish desperation streams from genuine opportunities
+ * Chirp Style: desperate_or_legit
+ */
+import { AnalysisTemplate } from '../template/AnalysisTemplate.js';
+import { ChirpIntelligence } from '../services/ChirpIntelligence.js';
+export class WeekendStreamAnalysis extends AnalysisTemplate {
+    yahooClient;
+    leagueId;
+    teamId;
+    constructor(yahooClient, leagueId, teamId) {
+        super('analyze_weekend_streams', 'streaming_recommendations');
+        this.yahooClient = yahooClient;
+        this.leagueId = leagueId;
+        this.teamId = teamId;
+    }
+    /**
+     * Semantic Identity for this analysis
+     */
+    getSemanticIdentity() {
+        return `
+🏒 Weekend Stream Classifier - ICE Analysis
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+SEMANTIC IDENTITY:
+  Tool: analyze_weekend_streams
+  Intent: I distinguish desperation streams from genuine opportunities
+  Classification: Binary decision tree (Desperation | Genuine | Monitor)
+  Time Horizon: Weekend tactical (3-7 day value)
+
+INTELLIGENCE LAYERS:
+  1. Schedule Analysis    - Weekend games, back-to-backs, opponents
+  2. Context Synthesis    - Team byes, injuries, roster gaps
+  3. Metrics Evaluation   - Recent PPG, projected FP/G, TOI trends
+  4. Risk Assessment      - Injury %, role volatility, matchup difficulty
+  5. Binary Classification - Decision tree logic
+  6. Fit Optimization     - Match to roster gaps, suggest drops
+  7. Confidence Scoring   - Upside score (0-100)
+
+UPSIDE FORMULA:
+  Score = (0.30 × Proj FP/G × 10) + (0.30 × Opp TOI) +
+          (0.20 × Schedule Ease) - (0.20 × Risk %)
+
+  Thresholds:
+    >60 = Genuine opportunity (sustainable, >2 week hold)
+    40-60 = Monitor territory (hot hand, risky matchup)
+    <40 = Desperation stream (bye/injury fill, <1 week)
+
+CHIRP STYLE: desperate_or_legit
+  "That's not a stream, that's a cry for help" 🆘
+  "PP1 lock? Now we're talking genuine upside" 🔥
+    `;
+    }
+    /**
+     * Layer 1: Fetch raw data
+     * - Free agents (position filtered, ownership capped)
+     * - User's roster (check byes/injuries)
+     * - Weekend schedule (date filtered)
+     * - Trending players
+     */
+    async fetchData(args) {
+        const ownershipMax = args.ownership_max || 50;
+        const positions = args.position_filter || ['C', 'LW', 'RW', 'D', 'G'];
+        // Fetch free agents across requested positions
+        const freeAgentPromises = positions.map(pos => this.yahooClient.searchPlayers(pos, 50, this.leagueId));
+        const [freeAgentResults, roster, trendingAdds] = await Promise.all([
+            Promise.all(freeAgentPromises),
+            this.yahooClient.getTeamRoster(this.leagueId, this.teamId),
+            this.yahooClient.getTrendingPlayers('add', 25, this.leagueId)
+        ]);
+        // Combine and deduplicate free agents
+        const allFreeAgents = [];
+        for (const result of freeAgentResults) {
+            if (result.players) {
+                allFreeAgents.push(...result.players);
+            }
+        }
+        const uniqueFreeAgents = Array.from(new Map(allFreeAgents.map(p => [p.player_id, p])).values()).filter(p => (p.percent_owned || 0) <= ownershipMax);
+        return {
+            freeAgents: uniqueFreeAgents,
+            roster,
+            trendingAdds: trendingAdds.players || [],
+            dateRange: args.date_range
+        };
+    }
+    /**
+     * Layer 2: Prepare data for analysis
+     * - Identify roster gaps (byes, injuries)
+     * - Fetch weekend schedules
+     * - Structure for analysis
+     */
+    async prepareData(rawData, args) {
+        // Identify roster gaps
+        const rosterGaps = this.identifyRosterGaps(rawData.roster, args);
+        // Get weekend schedules for each free agent
+        // (In real implementation, would fetch NHL schedule API)
+        const weekendSchedules = this.mockWeekendSchedules(rawData.freeAgents, rawData.dateRange);
+        // Return with custom properties attached
+        const result = {
+            availablePlayers: rawData.freeAgents,
+            roster: rawData.roster,
+            trendingPlayers: rawData.trendingAdds,
+            rosterGaps: rosterGaps,
+            weekendSchedules: weekendSchedules
+        };
+        return result;
+    }
+    /**
+     * Layer 2: Identify roster gaps from user's team
+     */
+    identifyRosterGaps(roster, args) {
+        const byeTeams = [];
+        const injuredPlayers = [];
+        const positionNeeds = [];
+        // Check roster for injuries
+        if (roster.players) {
+            for (const player of roster.players) {
+                if (player.status && player.status !== '' && player.status !== 'Healthy') {
+                    injuredPlayers.push(`${player.name} (${player.team})`);
+                }
+            }
+        }
+        // Parse team_needs if provided
+        if (args.team_needs) {
+            for (const need of args.team_needs) {
+                if (need === 'bye_fill') {
+                    // User indicated bye week gaps
+                    byeTeams.push('User indicated bye week');
+                }
+                else if (need === 'injury_cover') {
+                    // User indicated injury coverage needed
+                }
+                else if (need.includes('_')) {
+                    // Position needs like "G_volume", "C_depth"
+                    const pos = need.split('_')[0];
+                    if (!positionNeeds.includes(pos)) {
+                        positionNeeds.push(pos);
+                    }
+                }
+            }
+        }
+        return {
+            bye_teams: byeTeams,
+            injured_players: injuredPlayers,
+            position_needs: positionNeeds,
+            gaps_count: byeTeams.length + injuredPlayers.length
+        };
+    }
+    /**
+     * Layer 3: Mock weekend schedules
+     * (In production, integrate with NHL Schedule API)
+     */
+    mockWeekendSchedules(players, dateRange) {
+        const schedules = new Map();
+        for (const player of players) {
+            // Mock 1-3 weekend games
+            const gameCount = Math.floor(Math.random() * 3) + 1;
+            const games = [];
+            for (let i = 0; i < gameCount; i++) {
+                games.push({
+                    date: dateRange.start,
+                    opponent: this.getRandomOpponent(player.team),
+                    home: Math.random() > 0.5
+                });
+            }
+            schedules.set(player.player_id, {
+                player_id: player.player_id,
+                games,
+                game_count: gameCount,
+                has_back_to_back: gameCount >= 2 && Math.random() > 0.7
+            });
+        }
+        return schedules;
+    }
+    /**
+     * Layer 4: Execute weekend stream analysis
+     */
+    async analyzeData(data, args) {
+        const freeAgents = data.availablePlayers || [];
+        const dataAny = data;
+        const rosterGaps = dataAny.rosterGaps;
+        const schedules = dataAny.weekendSchedules;
+        // Score and classify each free agent
+        const scoredStreams = await Promise.all(freeAgents.map(player => this.analyzeStreamCandidate(player, rosterGaps, schedules, data)));
+        // Filter and sort by upside score
+        const minScore = args.min_upside_score || 0;
+        const sorted = scoredStreams
+            .filter(s => s.upside_score >= minScore)
+            .sort((a, b) => b.upside_score - a.upside_score);
+        // Separate by classification
+        const genuine = sorted.filter(s => s.classification === 'genuine');
+        const desperation = sorted.filter(s => s.classification === 'desperation');
+        const monitor = sorted.filter(s => s.classification === 'monitor');
+        // Top picks per classification
+        const maxResults = args.max_results || 10;
+        const topGenuine = genuine.slice(0, maxResults);
+        const topDesperation = desperation.slice(0, maxResults);
+        const topMonitor = monitor.slice(0, Math.floor(maxResults / 2));
+        return {
+            top_genuine: topGenuine,
+            top_desperation: topDesperation,
+            top_monitor: topMonitor,
+            all_streams: sorted.slice(0, 50),
+            classification_breakdown: {
+                genuine_count: genuine.length,
+                desperation_count: desperation.length,
+                monitor_count: monitor.length
+            },
+            roster_gaps: rosterGaps,
+            weekend_analysis: this.summarizeWeekendTrends(sorted, schedules)
+        };
+    }
+    /**
+     * Layer 5-7: Analyze single stream candidate through all intelligence layers
+     */
+    async analyzeStreamCandidate(player, gaps, schedules, data) {
+        // Get weekend schedule
+        const schedule = schedules.get(player.player_id) || {
+            player_id: player.player_id,
+            games: [],
+            game_count: 0,
+            has_back_to_back: false
+        };
+        // Layer 3: Metrics Evaluation
+        const metrics = await this.evaluateMetrics(player, data);
+        // Layer 1: Schedule Analysis
+        const scheduleAnalysis = this.analyzeScheduleEase(schedule, player);
+        // Layer 4: Risk Assessment
+        const risk = this.assessRisk(player, schedule, metrics);
+        // Layer 7: Upside Score Calculation
+        const upsideScore = this.calculateUpsideScore(metrics.projected_fpg, metrics.opportunity_toi, scheduleAnalysis.ease_score, risk.total_risk);
+        // Layer 2: Context Synthesis (is this driven by user's gaps?)
+        const contextDriven = this.isContextDriven(player, gaps);
+        // Layer 5: Binary Classification
+        const classification = this.classifyStream(upsideScore, contextDriven, metrics, risk.total_risk);
+        // Layer 6: Fit Optimization
+        const fitAnalysis = this.analyzeFit(player, gaps, classification);
+        return {
+            ...player,
+            classification,
+            upside_score: Math.round(upsideScore),
+            weekend_games: schedule.game_count,
+            schedule_ease: scheduleAnalysis.ease_score,
+            context_driven: contextDriven,
+            hold_duration: this.determineHoldDuration(classification, metrics),
+            catalyst: this.identifyCatalyst(player, metrics, schedule),
+            recent_ppg: metrics.recent_ppg,
+            projected_fpg: metrics.projected_fpg,
+            opportunity_toi: metrics.opportunity_toi,
+            risk_percentage: risk.total_risk,
+            matchup_quality: scheduleAnalysis.matchup_quality,
+            back_to_back: schedule.has_back_to_back,
+            drop_suggestion: fitAnalysis.drop_suggestion,
+            fit_reason: fitAnalysis.fit_reason
+        };
+    }
+    /**
+     * Layer 7: Calculate upside score (0-100)
+     * Formula: (0.30 × Proj FP/G × 10) + (0.30 × Opp TOI) + (0.20 × Schedule Ease) - (0.20 × Risk %)
+     */
+    calculateUpsideScore(projectedFpg, oppToi, scheduleEase, risk) {
+        const score = 0.30 * (projectedFpg * 10) +
+            0.30 * oppToi +
+            0.20 * scheduleEase -
+            0.20 * risk;
+        return Math.max(0, Math.min(100, score));
+    }
+    /**
+     * Layer 5: Binary Classification Decision Tree
+     */
+    classifyStream(upsideScore, contextDriven, metrics, risk) {
+        // Desperation: Context-driven + Low floor + High risk
+        if (contextDriven && upsideScore < 40) {
+            return 'desperation';
+        }
+        // Desperation: No role lock + Low score
+        if (metrics.opportunity_toi < 12 && upsideScore < 45) {
+            return 'desperation';
+        }
+        // Genuine: High upside + Independent catalysts + Low risk
+        if (upsideScore >= 60 && !contextDriven && risk < 40) {
+            return 'genuine';
+        }
+        // Genuine: Strong role lock + Good projection
+        if (metrics.opportunity_toi >= 16 && upsideScore >= 55) {
+            return 'genuine';
+        }
+        // Monitor: Everything in between (50/50 territory)
+        return 'monitor';
+    }
+    /**
+     * Layer 3: Evaluate player metrics
+     */
+    async evaluateMetrics(player, data) {
+        // Mock metrics - in production, fetch real stats
+        const isTrending = data.trendingPlayers?.some((t) => t.player_id === player.player_id);
+        const basePerformance = Math.random() * 0.8 + 0.2; // 0.2 - 1.0 PPG
+        const recent_ppg = basePerformance;
+        const projected_fpg = isTrending ? basePerformance * 1.15 : basePerformance;
+        // TOI estimate (higher for better players)
+        const ownership = player.percent_owned || 0;
+        const opportunity_toi = 10 + (ownership / 100) * 10 + Math.random() * 5; // 10-25 min
+        return {
+            recent_ppg,
+            projected_fpg,
+            opportunity_toi,
+            pp_role: opportunity_toi > 18 ? 'PP1' : opportunity_toi > 15 ? 'PP2' : 'None',
+            line_position: opportunity_toi > 16 ? 'Top-6' : 'Bottom-6'
+        };
+    }
+    /**
+     * Layer 1: Analyze schedule ease
+     */
+    analyzeScheduleEase(schedule, player) {
+        if (schedule.game_count === 0) {
+            return { ease_score: 0, matchup_quality: 'average' };
+        }
+        // Base score on game count
+        let easeScore = schedule.game_count * 30;
+        // Bonus for multiple games
+        if (schedule.game_count >= 3)
+            easeScore += 15;
+        // Penalty for back-to-back
+        if (schedule.has_back_to_back)
+            easeScore -= 10;
+        // Opponent strength (mock - in production use team rankings)
+        const opponentStrength = Math.random() * 100;
+        if (opponentStrength < 30) {
+            easeScore += 20; // Weak opponent
+        }
+        else if (opponentStrength > 70) {
+            easeScore -= 15; // Strong opponent
+        }
+        const matchup_quality = opponentStrength < 30 ? 'elite' :
+            opponentStrength < 50 ? 'favorable' :
+                opponentStrength < 70 ? 'average' : 'difficult';
+        return {
+            ease_score: Math.max(0, Math.min(100, easeScore)),
+            matchup_quality
+        };
+    }
+    /**
+     * Layer 4: Assess risk
+     */
+    assessRisk(player, schedule, metrics) {
+        let totalRisk = 20; // Base risk
+        // Injury status
+        if (player.status && player.status !== '' && player.status !== 'Healthy') {
+            totalRisk += 30;
+        }
+        // Low opportunity = higher risk
+        if (metrics.opportunity_toi < 12) {
+            totalRisk += 25;
+        }
+        // Back-to-back fatigue
+        if (schedule.has_back_to_back) {
+            totalRisk += 15;
+        }
+        // Low ownership = unproven = risk
+        const ownership = player.percent_owned || 0;
+        if (ownership < 10)
+            totalRisk += 15;
+        if (ownership > 30)
+            totalRisk -= 10; // Higher ownership = proven
+        return {
+            total_risk: Math.max(0, Math.min(100, totalRisk)),
+            factors: {
+                injury: player.status ? true : false,
+                low_toi: metrics.opportunity_toi < 12,
+                back_to_back: schedule.has_back_to_back,
+                low_ownership: ownership < 10
+            }
+        };
+    }
+    /**
+     * Layer 2: Check if stream is context-driven (bye/injury)
+     */
+    isContextDriven(player, gaps) {
+        // If user has gaps and player fills position need
+        if (gaps.position_needs.length > 0) {
+            const playerPositions = player.position.split(',');
+            for (const pos of playerPositions) {
+                if (gaps.position_needs.includes(pos)) {
+                    return true;
+                }
+            }
+        }
+        // If significant roster gaps exist, assume context-driven
+        return gaps.gaps_count > 2;
+    }
+    /**
+     * Determine hold duration based on classification
+     */
+    determineHoldDuration(classification, metrics) {
+        if (classification === 'genuine' && metrics.opportunity_toi >= 16) {
+            return '>2 weeks';
+        }
+        if (classification === 'monitor') {
+            return '1-2 weeks';
+        }
+        return '<1 week';
+    }
+    /**
+     * Identify catalyst for stream opportunity
+     */
+    identifyCatalyst(player, metrics, schedule) {
+        if (metrics.pp_role === 'PP1')
+            return 'PP1 role lock - power play opportunity';
+        if (metrics.line_position === 'Top-6')
+            return 'Top-6 linemate upgrade';
+        if (schedule.game_count >= 3)
+            return `${schedule.game_count} games this weekend`;
+        if (schedule.has_back_to_back)
+            return 'Back-to-back games - volume play';
+        if (metrics.recent_ppg > 0.7)
+            return 'Hot streak - riding momentum';
+        return 'Schedule-based streaming opportunity';
+    }
+    /**
+     * Layer 6: Analyze fit to roster gaps
+     */
+    analyzeFit(player, gaps, classification) {
+        let fitReason = '';
+        let dropSuggestion;
+        // Check position fit
+        const playerPositions = player.position.split(',');
+        const matchesNeed = playerPositions.some(pos => gaps.position_needs.includes(pos));
+        if (matchesNeed) {
+            fitReason = `Fills ${gaps.position_needs.join('/')} need`;
+        }
+        else if (gaps.gaps_count > 0) {
+            fitReason = 'General roster depth add';
+        }
+        else {
+            fitReason = 'Speculative opportunity';
+        }
+        // Suggest drop for genuine opportunities
+        if (classification === 'genuine') {
+            dropSuggestion = 'Drop lowest-scoring player in position';
+        }
+        return {
+            fit_reason: fitReason,
+            drop_suggestion: dropSuggestion,
+            matches_position_need: matchesNeed
+        };
+    }
+    /**
+     * Summarize weekend trends
+     */
+    summarizeWeekendTrends(streams, schedules) {
+        const totalGames = Array.from(schedules.values())
+            .reduce((sum, s) => sum + s.game_count, 0);
+        const avgGamesPerPlayer = schedules.size > 0 ? totalGames / schedules.size : 0;
+        const backToBackCount = Array.from(schedules.values())
+            .filter(s => s.has_back_to_back).length;
+        return {
+            total_weekend_games: totalGames,
+            avg_games_per_player: Math.round(avgGamesPerPlayer * 10) / 10,
+            back_to_back_situations: backToBackCount,
+            top_matchup_players: streams
+                .filter(s => s.matchup_quality === 'elite' || s.matchup_quality === 'favorable')
+                .length
+        };
+    }
+    /**
+     * Generate random opponent (mock)
+     */
+    getRandomOpponent(excludeTeam) {
+        const teams = ['BOS', 'CAR', 'COL', 'DAL', 'EDM', 'FLA', 'NYR', 'TOR', 'VGK', 'WPG'];
+        const filtered = teams.filter(t => t !== excludeTeam);
+        return filtered[Math.floor(Math.random() * filtered.length)];
+    }
+    /**
+     * Generate chirp intelligence
+     */
+    async generateChirp(analysisResults, semanticContract, data) {
+        if (semanticContract.enable_chirp === false) {
+            return analysisResults;
+        }
+        // Custom chirp messages for weekend streams
+        const chirpMessages = this.generateWeekendChirps(analysisResults);
+        const enhanced = ChirpIntelligence.enhance('analyze_weekend_streams', {
+            ...analysisResults,
+            streaming_targets: analysisResults.top_genuine,
+            recommendations: analysisResults.top_genuine
+        }, semanticContract);
+        // Override with custom chirps
+        if (enhanced.chirp_intelligence) {
+            enhanced.chirp_intelligence.analysis_chirp = chirpMessages.main;
+            enhanced.chirp_intelligence.ice_cold_truth = chirpMessages.truth;
+            enhanced.chirp_intelligence.style = 'desperate_or_legit';
+        }
+        return enhanced;
+    }
+    /**
+     * Generate custom chirps for weekend streams
+     */
+    generateWeekendChirps(results) {
+        const { top_genuine, top_desperation, roster_gaps } = results;
+        let mainChirp = '';
+        let truth = '';
+        if (top_genuine.length === 0 && top_desperation.length > 5) {
+            mainChirp = "🆘 That's not a waiver wire, that's a cry for help. Pure desperation plays everywhere.";
+            truth = "Weekend streaming desperation detected. You're filling holes, not building wins.";
+        }
+        else if (top_genuine.length >= 3) {
+            mainChirp = `🔥 Found ${top_genuine.length} genuine opportunities. PP1 locks, top-6 roles, sustainable upside. This is how you dominate.`;
+            truth = "These aren't streams, they're season savers. Act fast.";
+        }
+        else if (roster_gaps.gaps_count > 3) {
+            mainChirp = "⚠️ Multiple roster gaps detected. You're in triage mode - prioritize high-floor plays.";
+            truth = "Desperation mode activated. Take the best available, worry about upside later.";
+        }
+        else {
+            mainChirp = "📊 Mixed bag this weekend. Some genuine plays, some desperation. Choose wisely.";
+            truth = "Monitor territory - hot hands with risky matchups. Tread carefully.";
+        }
+        return { main: mainChirp, truth };
+    }
+    /**
+     * Format final response
+     */
+    async formatResponse(chirpEnhanced, data) {
+        const recommendations = [];
+        // Add genuine opportunities as HIGH priority
+        for (const stream of chirpEnhanced.top_genuine || []) {
+            recommendations.push({
+                priority: 'HIGH',
+                action: 'pickup',
+                player: stream,
+                reasoning: `Genuine: ${stream.fit_reason} (Score: ${stream.upside_score})`
+            });
+        }
+        // Add monitor targets as MEDIUM priority
+        for (const stream of chirpEnhanced.top_monitor || []) {
+            recommendations.push({
+                priority: 'MEDIUM',
+                action: 'watch', // 'monitor' as watch action
+                player: stream,
+                reasoning: `Monitor: ${stream.fit_reason} (Score: ${stream.upside_score})`
+            });
+        }
+        const insights = {
+            streaming_targets: chirpEnhanced.top_genuine,
+            favorable_teams: [],
+            market_intelligence: {
+                total_trending: data.trendingPlayers?.length || 0,
+                favorable_teams_count: 0,
+                top_trending_team: 'Weekend Focus'
+            }
+        };
+        return {
+            analysis_insights: insights,
+            recommendations,
+            chirp_intelligence: chirpEnhanced.chirp_intelligence || this.getDefaultChirp(),
+            metadata: {
+                analysis_type: this.analysisType,
+                tool_identity: 'weekend_stream_analysis',
+                generated_at: new Date().toISOString(),
+                semantic_contract_applied: true,
+                ...(chirpEnhanced.weekend_analysis && { weekend_summary: chirpEnhanced.weekend_analysis }),
+                ...(chirpEnhanced.classification_breakdown && { classification_breakdown: chirpEnhanced.classification_breakdown }),
+                ...(chirpEnhanced.roster_gaps && { roster_gaps: chirpEnhanced.roster_gaps })
+            }
+        };
+    }
+    /**
+     * Default chirp when chirp intelligence is disabled
+     */
+    getDefaultChirp() {
+        return {
+            tool_identity: 'weekend_stream_analysis',
+            style: 'desperate_or_legit',
+            personality: 'tactical_analyzer',
+            intensity: 'ice_cold',
+            semantic_context: 'weekend_streaming_classification',
+            analysis_chirp: 'Weekend stream analysis complete - desperation vs genuine classified',
+            intent_summary: 'Streaming opportunities identified and categorized',
+            ice_cold_truth: 'Smart weekend streams build championships, desperate ones fill holes',
+            energy_level: 'tactical'
+        };
+    }
+}

package/build/config/chirp-styles.js

@@ -0,0 +1,36 @@
+/**
+ * 🏒 Chirp Styles Configuration
+ *
+ * Defines the tone and energy levels for chirp intelligence responses.
+ * Each style maps to a semantic context for how the system communicates.
+ *
+ * Governance Note:
+ * These are semantic descriptors, not technical configurations.
+ * The style choice drives the semantic approach to response generation.
+ */
+export const CHIRP_STYLES = {
+    gentle: {
+        tone: "encouraging",
+        energy: "supportive",
+        prefix: "Consider",
+        suffix: "when you're ready"
+    },
+    standard: {
+        tone: "direct_honest",
+        energy: "confident",
+        prefix: "Time to",
+        suffix: "and improve your game"
+    },
+    savage: {
+        tone: "brutal_truth",
+        energy: "aggressive",
+        prefix: "Bro,",
+        suffix: "Get it together!"
+    },
+    ice_cold: {
+        tone: "championship_enforcer",
+        energy: "intimidating_confidence",
+        prefix: "Listen up, future champion -",
+        suffix: "That's how legends are made."
+    }
+};

package/build/config/personality-modes.js

@@ -0,0 +1,36 @@
+/**
+ * 🏒 Personality Modes Configuration
+ *
+ * Defines the voice and focus for different chirp intelligence personalities.
+ * Each mode represents a distinct semantic persona for commentary generation.
+ *
+ * Governance Note:
+ * These are semantic personas, not technical configurations.
+ * The personality choice determines the semantic approach to advice and commentary.
+ */
+export const PERSONALITY_MODES = {
+    analytical: {
+        focus: "data_driven",
+        style: "smart chirps with stats backing",
+        voice: "hockey_statistician",
+        phrases: ["The data shows", "Analysis indicates", "Stats don't lie"]
+    },
+    motivational: {
+        focus: "championship_mindset",
+        style: "pump-up chirps that inspire action",
+        voice: "championship_coach",
+        phrases: ["You've got this", "Championship teams", "Winners do this"]
+    },
+    roast_master: {
+        focus: "entertainment_value",
+        style: "savage roasts with hockey humor",
+        voice: "locker_room_comedian",
+        phrases: ["Buddy,", "That's like", "Even my grandmother"]
+    },
+    championship_coach: {
+        focus: "winning_strategy",
+        style: "tough love with clear direction",
+        voice: "elite_level_mentor",
+        phrases: ["Elite players", "Championship strategy", "Next level thinking"]
+    }
+};