@gotza02/sequential-thinking 10000.2.0 → 10000.2.1

package/dist/tools/sports/tools/match.js

@@ -30,6 +30,27 @@ function normalizeTeamName(name) {
         .replace(/\s+/g, ' ')
         .trim();
 }
+/**
+ * Check if a team name matches exactly or is contained within another name
+ * Uses more strict matching to avoid false positives
+ */
+function isTeamMatch(teamName, matchName) {
+    const normalizedSearch = normalizeTeamName(teamName);
+    const normalizedMatch = normalizeTeamName(matchName);
+    // Exact match
+    if (normalizedSearch === normalizedMatch)
+        return true;
+    // Check if search is contained as a word in match
+    const searchWords = normalizedSearch.split(/\s+/).filter(w => w.length > 2);
+    const matchWords = normalizedMatch.split(/\s+/).filter(w => w.length > 2);
+    // Must have at least one significant word in common
+    const commonWords = searchWords.filter(w => matchWords.includes(w));
+    // For longer names, require more matching words
+    if (searchWords.length >= 2) {
+        return commonWords.length >= Math.min(2, searchWords.length);
+    }
+    return commonWords.length > 0;
+}
 /**
  * Try to find match ID from API by team names and league
  */
@@ -48,9 +69,9 @@ async function findMatchId(homeTeam, awayTeam, league) {
         if (liveResult.success && liveResult.data) {
             const match = liveResult.data.find(m => {
                 const isHomeMatch = homeIds.includes(m.homeTeam.id) ||
-                    normalizeTeamName(m.homeTeam.name).includes(normalizeTeamName(homeTeam));
+                    isTeamMatch(homeTeam, m.homeTeam.name);
                 const isAwayMatch = awayIds.includes(m.awayTeam.id) ||
-                    normalizeTeamName(m.awayTeam.name).includes(normalizeTeamName(awayTeam));
+                    isTeamMatch(awayTeam, m.awayTeam.name);
                 return isHomeMatch && isAwayMatch;
             });
             if (match)
@@ -248,7 +269,7 @@ function formatH2HData(h2h, homeTeam, awayTeam) {
  * Get match result character (W/D/L) for a team
  */
 function getMatchResultChar(match, teamName) {
-    const isHome = match.homeTeam.name.includes(teamName);
+    const isHome = isTeamMatch(teamName, match.homeTeam.name);
     const homeScore = match.score?.home ?? 0;
     const awayScore = match.score?.away ?? 0;
     if (isHome) {
@@ -265,7 +286,8 @@ function formatTeamForm(form, teamName, isHomeTeam) {
     const label = isHomeTeam ? 'Home' : 'Away';
     let output = `### ${teamName} Recent Form (Last ${form.length})\n`;
     output += form.map(m => {
-        const opponent = isHomeTeam ? m.awayTeam.name : m.homeTeam.name;
+        const isHomeInMatch = isTeamMatch(teamName, m.homeTeam.name);
+        const opponent = isHomeInMatch ? m.awayTeam.name : m.homeTeam.name;
         const score = m.score ? `${m.score.home}-${m.score.away}` : '?';
         const result = getMatchResultChar(m, teamName);
         return `- ${result} vs ${opponent} (${score})`;
@@ -472,15 +494,19 @@ function calculateProbabilityRange(baseProbability, dataQuality) {
     // Higher data quality = narrower range
     const qualityFactor = dataQuality.score / 100;
     const baseUncertainty = 0.15; // 15% base uncertainty
-    // Adjust uncertainty based on data quality
+    // Adjust uncertainty based on data quality (better quality = smaller range)
     const adjustedUncertainty = baseUncertainty * (1 - qualityFactor * 0.7);
-    // Calculate range
+    // Calculate range using standard error formula
+    // For binomial proportion: SE = sqrt(p*(1-p)/n)
+    // We use a simplified version based on data quality
     const mid = baseProbability;
-    const margin = adjustedUncertainty * Math.sqrt(baseProbability * (1 - baseProbability));
+    // Margin decreases with better data quality
+    // Using 1.96 for ~95% confidence interval (2 standard deviations)
+    const margin = adjustedUncertainty * Math.sqrt(mid * (1 - mid) + 0.1);
     return {
-        low: Math.max(0, mid - margin * 1.645), // 5th percentile
-        mid,
-        high: Math.min(1, mid + margin * 1.645), // 95th percentile
+        low: Math.max(0, mid - margin * 1.96),
+        mid: Math.min(1, Math.max(0, mid)),
+        high: Math.min(1, mid + margin * 1.96),
     };
 }
 /**
@@ -493,22 +519,33 @@ async function detectValueBets(apiData, homeTeam, awayTeam) {
     // Estimate probabilities from API data
     // Simple model: use form and H2H to estimate
     let homeWinProb = 0.33;
-    let drawProb = 0.33;
+    let drawProb = 0.34;
     let awayWinProb = 0.33;
-    if (apiData.homeForm && apiData.awayForm) {
-        const homeWins = apiData.homeForm.filter(m => {
-            const isHome = m.homeTeam.name.includes(homeTeam);
-            return isHome ? (m.score?.home ?? 0) > (m.score?.away ?? 0) : (m.score?.away ?? 0) > (m.score?.home ?? 0);
-        }).length;
-        const awayWins = apiData.awayForm.filter(m => {
-            const isAway = m.awayTeam.name.includes(awayTeam);
-            return isAway ? (m.score?.away ?? 0) > (m.score?.home ?? 0) : (m.score?.home ?? 0) > (m.score?.away ?? 0);
-        }).length;
-        // Normalize to probabilities
-        const total = homeWins + awayWins + 2; // +2 for draws
-        homeWinProb = (homeWins + 1) / total;
-        awayWinProb = (awayWins + 1) / total;
-        drawProb = 1 - homeWinProb - awayWinProb;
+    if (apiData.homeForm?.length && apiData.awayForm?.length) {
+        // Calculate form based on points (3 for win, 1 for draw)
+        const homePoints = calculateFormPoints(apiData.homeForm, homeTeam);
+        const awayPoints = calculateFormPoints(apiData.awayForm, awayTeam);
+        // Number of matches played
+        const homeMatches = apiData.homeForm.length;
+        const awayMatches = apiData.awayForm.length;
+        // Points per game
+        const homePPG = homePoints / homeMatches;
+        const awayPPG = awayPoints / awayMatches;
+        // Max PPG is 3, so normalize to probability
+        // Give small bonus to home team (home advantage ~5-10%)
+        const totalPPG = homePPG + awayPPG;
+        if (totalPPG > 0) {
+            homeWinProb = Math.min(0.6, (homePPG / totalPPG) * 0.9 + 0.05); // Home advantage
+            awayWinProb = Math.min(0.5, (awayPPG / totalPPG) * 0.9);
+            // Draw probability based on how close the teams are
+            const ppgDiff = Math.abs(homePPG - awayPPG);
+            drawProb = Math.max(0.15, 0.35 - ppgDiff * 0.1); // Closer teams = higher draw chance
+            // Normalize to ensure sum = 1
+            const total = homeWinProb + drawProb + awayWinProb;
+            homeWinProb /= total;
+            drawProb /= total;
+            awayWinProb /= total;
+        }
     }
     // Calculate value for each market
     const markets = [
@@ -537,6 +574,100 @@ async function detectValueBets(apiData, homeTeam, awayTeam) {
             });
         }
     }
+    // Check Asian Handicap market if available
+    if (apiData.odds.asianHandicap) {
+        const ah = apiData.odds.asianHandicap;
+        // Estimate AH probability based on match probabilities and line
+        // Simplified: home wins if they overcome the handicap
+        const ahHomeProb = homeWinProb + (drawProb * 0.5); // Approximate
+        const ahAwayProb = awayWinProb + (drawProb * 0.5);
+        if (ah.home && ahHomeProb > 0) {
+            const fairOdds = 1 / ahHomeProb;
+            const value = (ah.home / fairOdds) - 1;
+            if (value >= 0.05) {
+                const kelly = (ahHomeProb * ah.home - 1) / (ah.home - 1);
+                valueBets.push({
+                    selection: `${homeTeam} AH ${ah.line > 0 ? '+' : ''}${ah.line}`,
+                    market: 'asian_handicap',
+                    odds: ah.home,
+                    fairOdds,
+                    value,
+                    confidence: Math.min(90, 50 + value * 200),
+                    kellyFraction: Math.max(0, kelly / 2),
+                    recommendedStake: Math.max(0, kelly / 2) * 100,
+                    reasoning: `Line ${ah.line}, estimated prob ${(ahHomeProb * 100).toFixed(1)}%`,
+                });
+            }
+        }
+        if (ah.away && ahAwayProb > 0) {
+            const fairOdds = 1 / ahAwayProb;
+            const value = (ah.away / fairOdds) - 1;
+            if (value >= 0.05) {
+                const kelly = (ahAwayProb * ah.away - 1) / (ah.away - 1);
+                valueBets.push({
+                    selection: `${awayTeam} AH ${ah.line > 0 ? '-' : '+'}${Math.abs(ah.line)}`,
+                    market: 'asian_handicap',
+                    odds: ah.away,
+                    fairOdds,
+                    value,
+                    confidence: Math.min(90, 50 + value * 200),
+                    kellyFraction: Math.max(0, kelly / 2),
+                    recommendedStake: Math.max(0, kelly / 2) * 100,
+                    reasoning: `Line ${-ah.line}, estimated prob ${(ahAwayProb * 100).toFixed(1)}%`,
+                });
+            }
+        }
+    }
+    // Check Over/Under market if available
+    if (apiData.odds.overUnder) {
+        const ou = apiData.odds.overUnder;
+        // Estimate over probability based on expected goals
+        const expectedTotal = (apiData.homeForm?.length && apiData.awayForm?.length)
+            ? calculateExpectedGoals(apiData, homeTeam, awayTeam)
+            : { home: 1.5, away: 1.2 };
+        const totalXG = expectedTotal.home + expectedTotal.away;
+        // Simple model: over if total xG > line
+        const overProb = totalXG > ou.line
+            ? 0.5 + (totalXG - ou.line) * 0.1
+            : 0.5 - (ou.line - totalXG) * 0.1;
+        const underProb = 1 - overProb;
+        if (ou.over && overProb > 0) {
+            const fairOdds = 1 / Math.min(0.9, Math.max(0.1, overProb));
+            const value = (ou.over / fairOdds) - 1;
+            if (value >= 0.05) {
+                const kelly = (overProb * ou.over - 1) / (ou.over - 1);
+                valueBets.push({
+                    selection: `Over ${ou.line}`,
+                    market: 'over_under',
+                    odds: ou.over,
+                    fairOdds,
+                    value,
+                    confidence: Math.min(90, 50 + value * 200),
+                    kellyFraction: Math.max(0, kelly / 2),
+                    recommendedStake: Math.max(0, kelly / 2) * 100,
+                    reasoning: `Line ${ou.line}, expected goals ${totalXG.toFixed(1)}`,
+                });
+            }
+        }
+        if (ou.under && underProb > 0) {
+            const fairOdds = 1 / Math.min(0.9, Math.max(0.1, underProb));
+            const value = (ou.under / fairOdds) - 1;
+            if (value >= 0.05) {
+                const kelly = (underProb * ou.under - 1) / (ou.under - 1);
+                valueBets.push({
+                    selection: `Under ${ou.line}`,
+                    market: 'over_under',
+                    odds: ou.under,
+                    fairOdds,
+                    value,
+                    confidence: Math.min(90, 50 + value * 200),
+                    kellyFraction: Math.max(0, kelly / 2),
+                    recommendedStake: Math.max(0, kelly / 2) * 100,
+                    reasoning: `Line ${ou.line}, expected goals ${totalXG.toFixed(1)}`,
+                });
+            }
+        }
+    }
     return valueBets.sort((a, b) => b.value - a.value);
 }
 /**
@@ -544,7 +675,7 @@ async function detectValueBets(apiData, homeTeam, awayTeam) {
  */
 function calculateFormPoints(form, teamName) {
     return form.reduce((sum, m) => {
-        const isHome = m.homeTeam.name.includes(teamName);
+        const isHome = isTeamMatch(teamName, m.homeTeam.name);
         const score = m.score;
         if (!score)
             return sum;
@@ -558,16 +689,90 @@ function calculateFormPoints(form, teamName) {
     }, 0);
 }
 /**
- * Calculate probabilities from form data
+ * Calculate expected goals from form data
+ * Uses average goals scored and conceded to estimate xG
+ */
+function calculateExpectedGoals(apiData, homeTeam, awayTeam) {
+    if (!apiData?.homeForm?.length || !apiData?.awayForm?.length) {
+        // Default: league average with home advantage
+        return { home: 1.5, away: 1.2 };
+    }
+    // Calculate average goals scored and conceded for home team
+    let homeGoalsScored = 0;
+    let homeGoalsConceded = 0;
+    let homeMatchesWithScores = 0;
+    for (const match of apiData.homeForm) {
+        if (match.score) {
+            const isHomeInMatch = isTeamMatch(homeTeam, match.homeTeam.name);
+            homeGoalsScored += isHomeInMatch ? match.score.home : match.score.away;
+            homeGoalsConceded += isHomeInMatch ? match.score.away : match.score.home;
+            homeMatchesWithScores++;
+        }
+    }
+    // Calculate average goals scored and conceded for away team
+    let awayGoalsScored = 0;
+    let awayGoalsConceded = 0;
+    let awayMatchesWithScores = 0;
+    for (const match of apiData.awayForm) {
+        if (match.score) {
+            const isAwayInMatch = isTeamMatch(awayTeam, match.awayTeam.name);
+            awayGoalsScored += isAwayInMatch ? match.score.away : match.score.home;
+            awayGoalsConceded += isAwayInMatch ? match.score.home : match.score.away;
+            awayMatchesWithScores++;
+        }
+    }
+    // Calculate averages
+    const homeScoringAvg = homeMatchesWithScores > 0 ? homeGoalsScored / homeMatchesWithScores : 1.5;
+    const homeConcedingAvg = homeMatchesWithScores > 0 ? homeGoalsConceded / homeMatchesWithScores : 1.2;
+    const awayScoringAvg = awayMatchesWithScores > 0 ? awayGoalsScored / awayMatchesWithScores : 1.2;
+    const awayConcedingAvg = awayMatchesWithScores > 0 ? awayGoalsConceded / awayMatchesWithScores : 1.5;
+    // xG estimate using average of "what team scores" and "what opponent concedes"
+    // with home advantage adjustment
+    const homeAdvantage = 1.15; // ~15% boost for home
+    const homeXG = ((homeScoringAvg + awayConcedingAvg) / 2) * homeAdvantage;
+    const awayXG = (awayScoringAvg + homeConcedingAvg) / 2;
+    // Clamp to reasonable values (0.5 to 3.5 goals)
+    return {
+        home: Math.min(3.5, Math.max(0.5, homeXG)),
+        away: Math.min(3.5, Math.max(0.5, awayXG)),
+    };
+}
+/**
+ * Calculate probabilities from form data using proper normalization
  */
 function calculateProbabilitiesFromForm(homeForm, awayForm, homeTeam, awayTeam) {
     const homePoints = calculateFormPoints(homeForm, homeTeam);
     const awayPoints = calculateFormPoints(awayForm, awayTeam);
-    const totalPoints = homePoints + awayPoints + 5; // +5 for draw possibility
+    // Points per game
+    const homePPG = homePoints / Math.max(1, homeForm.length);
+    const awayPPG = awayPoints / Math.max(1, awayForm.length);
+    // Use Bradley-Terry inspired model
+    // Convert PPG to relative strength (max 3 points per game)
+    const homeStrength = homePPG / 3;
+    const awayStrength = awayPPG / 3;
+    // Apply home advantage (~10% boost)
+    const homeAdvantage = 1.1;
+    const effectiveHomeStrength = homeStrength * homeAdvantage;
+    // Calculate probabilities
+    const totalStrength = effectiveHomeStrength + awayStrength;
+    if (totalStrength < 0.1) {
+        // Not enough data, return defaults
+        return { homeWin: 0.35, draw: 0.30, awayWin: 0.35 };
+    }
+    // Raw win probabilities (before draw adjustment)
+    const rawHomeWin = effectiveHomeStrength / totalStrength;
+    const rawAwayWin = awayStrength / totalStrength;
+    // Draw probability based on how close teams are
+    // When teams are equal, draw probability is higher
+    const strengthDiff = Math.abs(homeStrength - awayStrength);
+    const drawProb = Math.max(0.15, 0.30 - strengthDiff * 0.3);
+    // Adjust win probabilities to account for draw
+    const remainingProb = 1 - drawProb;
+    const winRatio = rawHomeWin / (rawHomeWin + rawAwayWin);
     return {
-        homeWin: (homePoints + 1.5) / totalPoints,
-        draw: 5 / totalPoints,
-        awayWin: (awayPoints + 1.5) / totalPoints,
+        homeWin: remainingProb * winRatio,
+        draw: drawProb,
+        awayWin: remainingProb * (1 - winRatio),
     };
 }
 /**
@@ -609,7 +814,7 @@ async function buildStructuredAnalysis(homeTeam, awayTeam, league, apiData, cove
             homeWinProbability: predictions.matchResult.homeWin,
             drawProbability: predictions.matchResult.draw,
             awayWinProbability: predictions.matchResult.awayWin,
-            expectedGoals: { home: 1.3, away: 1.2 }, // Placeholder - would need xG data
+            expectedGoals: calculateExpectedGoals(apiData, homeTeam, awayTeam),
             keyStats: [],
         },
         tacticalScout: {
@@ -821,8 +1026,8 @@ Data cached for 1 minute.`, {
                 matches = result.data;
                 // Filter by team if specified
                 if (team) {
-                    matches = matches.filter((m) => m.homeTeam.name.toLowerCase().includes(team.toLowerCase()) ||
-                        m.awayTeam.name.toLowerCase().includes(team.toLowerCase()));
+                    matches = matches.filter((m) => isTeamMatch(team, m.homeTeam.name) ||
+                        isTeamMatch(team, m.awayTeam.name));
                 }
                 // Limit results
                 matches = matches.slice(0, limit);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gotza02/sequential-thinking",
-  "version": "10000.2.0",
+  "version": "10000.2.1",
   "publishConfig": {
     "access": "public"
   },

package/CLAUDE.md

@@ -1,231 +0,0 @@
-# SmartAgent Elite Controller - System Instructions
-
-You are an AI assistant powered by the Sequential Thinking MCP server (@gotza02/sequential-thinking@10000.1.9).
-
-## Critical Prime Directives
-
-1. **ALWAYS use sequentialthinking tool for complex tasks**
-   - Flow: Analysis → Planning → [Critique] → Execution → Observation → Reflection
-   - Confidence scoring: Track your certainty level (0-100)
-   - Block-based context: Group related thoughts
-
-2. **NEVER hallucinate information**
-   - Use web search (Brave/Exa/DuckDuckGo) for up-to-date facts
-   - Use sports APIs for match data
-   - Cache results appropriately
-
-3. **Safety protocols are mandatory**
-   - Auto-backup before file edits via deep_code_edit
-   - Ask human approval for destructive actions
-   - Path traversal checks enforced
-
-## Complete Tool Reference
-
-### 🧠 Sequential Thinking Tools
-| Tool | Purpose | When to Use |
-|------|---------|-------------|
-| `sequentialthinking` | Structured problem-solving | Complex tasks requiring multiple steps |
-| `analysis` | Break down requirements | Understanding the problem |
-| `planning` | Formulate execution plan | Before taking action |
-| `critique` | Review plan for risks | High-stakes decisions |
-| `execution` | Perform tool calls | During implementation |
-| `observation` | Record tool outputs | After each tool call |
-| `reflection` | Self-review and adjust | When stuck or after errors |
-| `hypothesis` | Form new theories | Based on observations |
-
-### ⚽ Sports Intelligence Tools
-| Tool | Purpose | When to Use |
-|------|---------|-------------|
-| `analyze_football_match_v2` | Comprehensive match analysis | Need detailed text analysis |
-| `analyze_football_match_structured` | JSON output with probabilities | Need programmatic data |
-| `get_live_scores` | Live football scores | Real-time match updates |
-| `get_match_details` | Match info by ID | Have specific match ID |
-| `get_team_stats` | Team performance data | Team analysis needed |
-| `compare_teams` | H2H team comparison | Compare two teams |
-| `get_player_stats` | Player statistics | Individual player analysis |
-| `odds_comparison` | Betting odds across markets | Find best odds |
-| `value_bet_calculator` | Kelly Criterion calculation | Betting recommendations |
-| `track_prediction` | Log bet/prediction | Start tracking a pick |
-| `resolve_prediction` | Update bet result | Mark win/loss/void |
-| `analyze_roi` | Performance analytics | Review betting history |
-| `get_pending_predictions` | List unresolved bets | Check open positions |
-
-**Sports Tool Priority:**
-1. Try `analyze_football_match_structured` first (gives JSON with confidence ranges)
-2. Fall back to `analyze_football_match_v2` for detailed narrative
-3. Use `value_bet_calculator` for specific betting math
-4. Always `track_prediction` after making picks
-
-### 🔍 Web Search & Research Tools
-| Tool | Purpose | API Key Required |
-|------|---------|------------------|
-| `brave_web_search` | General web search | BRAVE_API_KEY |
-| `exa_web_search` | Neural/semantic search | EXA_API_KEY |
-| `duckduckgo_search` | Anonymous search | None |
-| `web_read` | Extract URL content | None |
-| `web_extract` | Structured data extraction | None |
-
-**Search Strategy:**
-- Current events/news → `brave_web_search`
-- Research/technical → `exa_web_search`
-- Fallback/no key → `duckduckgo_search`
-- Deep dive → `web_read` on top results
-
-### 💻 Code Management Tools
-| Tool | Purpose | Safety Features |
-|------|---------|-----------------|
-| `deep_code_edit` | Structural code changes | Auto-backup, validation |
-| `add_code_snippet` | Store reusable patterns | Indexed for search |
-| `search_code` | Semantic code search | Graph-based relationships |
-| `get_project_graph` | Codebase structure analysis | File dependencies |
-| `get_file_relationships` | Find related files | Import/dependency graph |
-
-### 🧠 Intelligent Code Analysis Tools (v10000.1.9+)
-| Tool | Purpose | Features |
-|------|---------|----------|
-| `intelligent_code_analyze` | Deep code analysis | Quality scoring, metrics, issue detection |
-| `intelligent_impact_analysis` | Change prediction | Risk score, affected files, test recommendations |
-| `intelligent_semantic_search` | Concept-based search | Find code by meaning, not just text |
-| `intelligent_refactor_suggest` | Refactoring ideas | AI suggestions with before/after code |
-| `intelligent_code_compare` | Code comparison | Diff analysis with statistics |
-| `intelligent_code_autofix` | Auto-fix code issues | Trailing whitespace, semicolons, imports |
-
-**Intelligent Code Analysis Protocol:**
-1. Before major changes → `intelligent_impact_analysis` (know the risk)
-2. Understanding code → `intelligent_code_analyze` (quality + metrics)
-3. Finding related code → `intelligent_semantic_search` (concept search)
-4. Improving code → `intelligent_refactor_suggest` (actionable ideas)
-5. Code reviews → `intelligent_code_compare` (detailed diffs)
-6. Clean up issues → `intelligent_code_autofix` (dryRun first, then apply)
-7. Monitor quality → Check `http://localhost:3001/api/code-quality` for project overview
-
-**Code Edit Protocol:**
-1. Before changes: Run `intelligent_impact_analysis` to assess risk
-2. Always use `deep_code_edit` (not raw file writes)
-3. Review backup location if rollback needed
-4. Use `search_code` first to understand context
-5. Validate changes with `get_project_graph`
-
-### 📝 Knowledge & Notes Tools
-| Tool | Purpose | Persistence |
-|------|---------|-------------|
-| `add_note` | Create/store notes | Saved to disk |
-| `search_notes` | Find existing notes | Full-text search |
-| `get_note` | Retrieve specific note | By ID |
-| `update_note` | Modify existing note | Versioned |
-| `create_knowledge_node` | Add to knowledge graph | With relationships |
-| `query_knowledge_graph` | Traverse relationships | Multi-hop queries |
-| `add_knowledge_edge` | Connect nodes | Weighted relationships |
-
-### 👤 Human Interface Tools
-| Tool | Purpose | Use When |
-|------|---------|----------|
-| `ask_human` | Request clarification | Ambiguous requirements |
-| `request_workflow_approval` | Multi-step approval | Destructive workflows |
-| `send_notification` | Alert human user | Important updates |
-
-### 🛠️ Utility Tools
-| Tool | Purpose | Notes |
-|------|---------|-------|
-| `get_caller_info` | Get current context | Debug/diagnostics |
-| `get_server_metrics` | Performance stats | Resource monitoring |
-| `validate_path` | Security check | Path traversal prevention |
-| `generate_cache_key` | Create cache keys | Consistent hashing |
-
-## Tool Selection Flowchart
-
-```
-Need information?
-├── Time-sensitive/current → web_search (Brave/Exa)
-├── Sports data → analyze_football_match_*
-├── Code understanding → search_code / get_project_graph
-├── Past notes → search_notes
-└── General knowledge → sequentialthinking
-
-Need to take action?
-├── Code changes → deep_code_edit
-├── Code analysis → intelligent_code_analyze
-├── Impact prediction → intelligent_impact_analysis
-├── Refactoring ideas → intelligent_refactor_suggest
-├── Auto-fix issues → intelligent_code_autofix
-├── Store knowledge → add_note / create_knowledge_node
-├── Track sports bet → track_prediction
-└── Complex workflow → sequentialthinking → execution
-
-Need human input?
-├── Quick question → ask_human
-├── Destructive action → request_workflow_approval
-└── Important update → send_notification
-```
-
-## Environment Variables
-
-Required for full functionality:
-- `BRAVE_API_KEY` - Brave Search (web search)
-- `EXA_API_KEY` - Exa Neural Search (research)
-- `API_FOOTBALL_KEY` - API-Football (sports data)
-- `FOOTBALL_DATA_KEY` - Football-Data.org (backup sports)
-
-Optional:
-- `SPORTS_DB_KEY` - TheSportsDB (additional sports)
-- `GOOGLE_SEARCH_API_KEY` - Google Custom Search
-- `GOOGLE_SEARCH_CX` - Google Search Engine ID
-
-## Confidence Scoring Protocol
-
-Track your certainty level in sequential thinking:
-- **100-90**: Very high confidence, proceed directly
-- **89-70**: High confidence, brief verification
-- **69-50**: Medium confidence, use observation step
-- **49-30**: Low confidence, ask_human for clarification
-- **29-0**: Very low confidence, STOP and reflect
-
-## Loop Prevention Rules
-
-1. If same error occurs 3 times → STOP and ask_human
-2. If confidence drops below 50 → Use reflection step
-3. If stuck for 5+ thought cycles → Branch or ask_human
-4. If tool fails repeatedly → Try alternative tool
-
-## Response Format Guidelines
-
-For sports analysis:
-```
-📊 Data Quality: XX/100
-🏠 Home: X% (range: X%-X%)
-🤝 Draw: X% (range: X%-X%)
-✈️ Away: X% (range: X%-X%)
-💎 Value Bets: [list if any]
-🏆 Best Bet: [selection]
-```
-
-For code changes:
-```
-📝 Files Modified: [list]
-💾 Backup Location: [path]
-✅ Validation: [tests/status]
-🔍 Impact Analysis: [use intelligent_impact_analysis]
-📊 Code Quality: [use intelligent_code_analyze for metrics]
-```
-
-## Error Recovery
-
-Tool failure → Log error → Try alternative → If stuck, ask_human
-API limit → Switch provider → Use cache → If exhausted, inform user
-Path error → Validate_path → Check permissions → If persists, ask_human
-
----
-
-## MCP Configuration
-
-**Version:** `@gotza02/sequential-thinking@10000.1.9`
-
-**Claude Code Setup:** See `~/.claude/SEQUENTIAL_THINKING_MCP.md`
-
-**Gemini CLI Setup:** See `~/.gemini/GEMINI_MCP_SETUP.md`
-
-**Environment Variables Required:**
-- `BRAVE_API_KEY`, `EXA_API_KEY` - Web search
-- `API_FOOTBALL_KEY`, `FOOTBALL_DATA_KEY` - Sports data
-
-**Dashboard:** http://localhost:3001/api/code-quality