slashvibe-mcp 0.2.8 → 0.3.13

package/games/wordassociation.js

@@ -0,0 +1,247 @@
+/**
+ * Word Association game implementation for /vibe
+ * Players take turns saying words that associate with the previous word
+ * Build creative chains of connected ideas!
+ */
+
+// Simple word validation
+function isValidWord(word) {
+  // Basic checks: alphabetic, reasonable length, not too short
+  if (!/^[a-zA-Z\-']+$/.test(word)) return false; // Allow hyphens and apostrophes
+  if (word.length < 2) return false;
+  if (word.length > 30) return false;
+  
+  // Allow single meaningful words
+  if (word.length === 1) {
+    return ['a', 'i'].includes(word.toLowerCase());
+  }
+  
+  return true;
+}
+
+// Create initial word association state
+function createInitialWordAssociationState() {
+  return {
+    words: [],
+    players: [],
+    currentPlayer: null,
+    moves: 0,
+    gameOver: false,
+    winner: null,
+    lastWord: null,
+    usedWords: new Set(), // Track words to prevent exact repeats
+    playerTurnIndex: 0,
+    maxWords: 30, // End game after 30 words for now
+    associations: [], // Store word -> word pairs for fun stats
+    startedAt: new Date().toISOString()
+  };
+}
+
+// Add player to game
+function addPlayer(gameState, playerHandle) {
+  if (gameState.players.includes(playerHandle)) {
+    return { error: 'Player already in the game' };
+  }
+
+  if (gameState.players.length >= 6) {
+    return { error: 'Game is full (max 6 players)' };
+  }
+
+  const newPlayers = [...gameState.players, playerHandle];
+  
+  return {
+    success: true,
+    gameState: {
+      ...gameState,
+      players: newPlayers,
+      currentPlayer: gameState.currentPlayer || playerHandle // First player starts
+    }
+  };
+}
+
+// Make a word association move
+function makeMove(gameState, word, playerHandle) {
+  const { words, players, currentPlayer, moves, usedWords, lastWord, maxWords } = gameState;
+  
+  // Normalize word
+  const normalizedWord = word.toLowerCase().trim().replace(/['"]/g, '');
+  
+  // Validate basic word format
+  if (!isValidWord(normalizedWord)) {
+    return { error: 'Invalid word format. Use only letters (2-30 characters).' };
+  }
+  
+  // Check if it's the right player's turn (if multiplayer)
+  if (players.length > 1 && currentPlayer !== playerHandle) {
+    return { error: `Not your turn! Waiting for @${currentPlayer}` };
+  }
+  
+  // Check if word was already used (allow some flexibility)
+  if (usedWords.has(normalizedWord)) {
+    return { error: 'Word already used! Try a different word.' };
+  }
+  
+  // Check if it's the same word as last word
+  if (lastWord && normalizedWord === lastWord.toLowerCase()) {
+    return { error: 'Cannot repeat the same word immediately!' };
+  }
+  
+  // Valid move - update game state
+  const newWords = [...words, { word: normalizedWord, player: playerHandle, timestamp: new Date().toISOString() }];
+  const newUsedWords = new Set([...usedWords, normalizedWord]);
+  const newAssociations = lastWord ? [...gameState.associations, `${lastWord} → ${normalizedWord}`] : gameState.associations;
+  
+  // Determine next player
+  let nextPlayerIndex = gameState.playerTurnIndex;
+  let nextPlayer = currentPlayer;
+  
+  if (players.length > 1) {
+    nextPlayerIndex = (gameState.playerTurnIndex + 1) % players.length;
+    nextPlayer = players[nextPlayerIndex];
+  }
+  
+  // Check if game should end
+  const shouldEnd = moves + 1 >= maxWords;
+  
+  const newGameState = {
+    ...gameState,
+    words: newWords,
+    currentPlayer: shouldEnd ? null : nextPlayer,
+    playerTurnIndex: nextPlayerIndex,
+    moves: moves + 1,
+    gameOver: shouldEnd,
+    winner: shouldEnd ? 'everyone' : null,
+    lastWord: normalizedWord,
+    usedWords: newUsedWords,
+    associations: newAssociations
+  };
+  
+  return { success: true, gameState: newGameState };
+}
+
+// Format word association for display
+function formatWordAssociationDisplay(gameState) {
+  const { words, players, currentPlayer, moves, gameOver, maxWords, associations } = gameState;
+  
+  let display = `🧠 **Word Association** (${moves}/${maxWords} words)\n\n`;
+  
+  if (gameOver) {
+    display += '🎉 **Game Complete!** What a creative journey!\n\n';
+  }
+  
+  if (words.length === 0) {
+    if (players.length === 0) {
+      display += '**Start with any word!**\n\n';
+      display += 'Word association is about connecting ideas. Each new word should relate to the previous one.\n';
+    } else {
+      display += `**@${currentPlayer}, start us off with any word!**\n\n`;
+    }
+  } else {
+    // Show the association chain (last 8 words to keep it readable)
+    const recentWords = words.slice(-8);
+    const wordChain = recentWords.map(w => {
+      const capitalizedWord = w.word.charAt(0).toUpperCase() + w.word.slice(1);
+      return `**${capitalizedWord}** (@${w.player})`;
+    }).join(' → ');
+    
+    display += '**Chain:** ' + wordChain;
+    
+    if (words.length > 8) {
+      display += ` (showing last 8 of ${words.length})`;
+    }
+    
+    display += '\n\n';
+    
+    if (!gameOver) {
+      const lastWordEntry = words[words.length - 1];
+      const lastWord = lastWordEntry.word;
+      display += `**"${lastWord.charAt(0).toUpperCase() + lastWord.slice(1)}" makes you think of...**\n\n`;
+      
+      if (players.length > 1) {
+        display += `Turn: **@${currentPlayer}**`;
+      } else {
+        display += '**Your turn!** What word comes to mind?';
+      }
+    }
+  }
+  
+  // Show players if multiplayer
+  if (players.length > 1) {
+    display += `\n\n**Players (${players.length}):** ${players.map(p => `@${p}`).join(', ')}`;
+  }
+  
+  // Show some fun stats at the end
+  if (gameOver && associations.length > 0) {
+    display += '\n\n**Creative Journey:**\n';
+    // Show the full chain condensed
+    const fullChain = words.map(w => w.word.charAt(0).toUpperCase() + w.word.slice(1)).join(' → ');
+    display += fullChain;
+  }
+  
+  return display;
+}
+
+// Get game stats for fun
+function getGameStats(gameState) {
+  const { words, players, associations } = gameState;
+  
+  if (words.length === 0) return null;
+  
+  // Player contribution stats
+  const contributions = {};
+  words.forEach(w => {
+    contributions[w.player] = (contributions[w.player] || 0) + 1;
+  });
+  
+  return {
+    totalWords: words.length,
+    contributors: Object.keys(contributions).length,
+    contributions,
+    longestWord: Math.max(...words.map(w => w.word.length)),
+    shortestWord: Math.min(...words.map(w => w.word.length)),
+    uniqueWords: new Set(words.map(w => w.word)).size
+  };
+}
+
+// Check for interesting patterns or themes
+function findThemes(gameState) {
+  const { words } = gameState;
+  
+  if (words.length < 3) return [];
+  
+  const themes = [];
+  const wordList = words.map(w => w.word.toLowerCase());
+  
+  // Look for color words
+  const colors = ['red', 'blue', 'green', 'yellow', 'orange', 'purple', 'pink', 'black', 'white', 'brown', 'gray', 'grey'];
+  const colorWords = wordList.filter(w => colors.includes(w));
+  if (colorWords.length >= 2) {
+    themes.push(`🌈 Colors: ${colorWords.join(', ')}`);
+  }
+  
+  // Look for animal words
+  const animals = ['cat', 'dog', 'bird', 'fish', 'mouse', 'lion', 'tiger', 'bear', 'wolf', 'fox', 'rabbit', 'horse', 'cow', 'pig', 'sheep'];
+  const animalWords = wordList.filter(w => animals.some(animal => w.includes(animal) || animal.includes(w)));
+  if (animalWords.length >= 2) {
+    themes.push(`🐾 Animals: ${animalWords.join(', ')}`);
+  }
+  
+  // Look for nature words
+  const nature = ['tree', 'flower', 'water', 'sun', 'moon', 'star', 'cloud', 'rain', 'snow', 'mountain', 'ocean', 'forest'];
+  const natureWords = wordList.filter(w => nature.some(n => w.includes(n) || n.includes(w)));
+  if (natureWords.length >= 2) {
+    themes.push(`🌿 Nature: ${natureWords.join(', ')}`);
+  }
+  
+  return themes;
+}
+
+module.exports = {
+  createInitialWordAssociationState,
+  addPlayer,
+  makeMove,
+  formatWordAssociationDisplay,
+  isValidWord,
+  getGameStats,
+  findThemes
+};

package/games/wordchain.js

@@ -0,0 +1,135 @@
+/**
+ * Word Chain game implementation for /vibe
+ * Players take turns saying words that start with the last letter of the previous word
+ */
+
+// Simple word validation - checks if it's a reasonable English word
+// In a full implementation, this could use a proper dictionary API
+function isValidWord(word) {
+  // Basic checks: alphabetic, reasonable length, not too short
+  if (!/^[a-zA-Z]+$/.test(word)) return false;
+  if (word.length < 2) return false;
+  if (word.length > 20) return false;
+  
+  // Some very basic filtering of common valid words vs nonsense
+  // This is a simplified check - a real game would use a dictionary
+  const commonPrefixes = ['th', 'he', 'in', 'er', 'an', 're', 'ed', 'nd', 'ou', 'ea', 'ti', 'to', 'it', 'st', 'io', 'le', 'is', 'on', 'ur', 'ar', 'nt', 'al'];
+  const commonSuffixes = ['ed', 'er', 'ing', 'ly', 'est', 'ion', 'tion', 'sion', 'ness', 'ment', 'able', 'ible'];
+  
+  const lowerWord = word.toLowerCase();
+  
+  // Allow single letters for now (like 'a', 'i')
+  if (word.length === 1) {
+    return ['a', 'i'].includes(lowerWord);
+  }
+  
+  // Check for common patterns that suggest it's a real word
+  const hasCommonPrefix = commonPrefixes.some(prefix => lowerWord.startsWith(prefix));
+  const hasCommonSuffix = commonSuffixes.some(suffix => lowerWord.endsWith(suffix));
+  
+  // Very permissive check - if it looks word-like, allow it
+  // Real implementation would check against dictionary
+  return hasCommonPrefix || hasCommonSuffix || lowerWord.length >= 3;
+}
+
+// Create initial word chain state
+function createInitialWordChainState() {
+  return {
+    words: [],
+    currentPlayer: 'player1', // player1 starts (the person who initiated the game)
+    moves: 0,
+    gameOver: false,
+    winner: null,
+    lastLetter: null,
+    usedWords: new Set() // Track words to prevent repeats
+  };
+}
+
+// Make a word chain move
+function makeMove(gameState, word, isPlayer1Move) {
+  const { words, currentPlayer, moves, usedWords, lastLetter } = gameState;
+  
+  // Normalize word
+  const normalizedWord = word.toLowerCase().trim();
+  
+  // Validate basic word format
+  if (!isValidWord(normalizedWord)) {
+    return { error: 'Invalid word format. Use only letters, 2-20 characters.' };
+  }
+  
+  // Check if it's the right player's turn
+  const expectedPlayer = currentPlayer === 'player1' ? true : false;
+  if (isPlayer1Move !== expectedPlayer) {
+    return { error: 'Not your turn!' };
+  }
+  
+  // Check if word was already used
+  if (usedWords.has(normalizedWord)) {
+    return { error: 'Word already used! Try a different word.' };
+  }
+  
+  // Check if word starts with the required letter
+  if (lastLetter && normalizedWord[0] !== lastLetter) {
+    return { error: `Word must start with "${lastLetter.toUpperCase()}"` };
+  }
+  
+  // Valid move - update game state
+  const newWords = [...words, normalizedWord];
+  const newUsedWords = new Set([...usedWords, normalizedWord]);
+  const newLastLetter = normalizedWord[normalizedWord.length - 1];
+  const newCurrentPlayer = currentPlayer === 'player1' ? 'player2' : 'player1';
+  
+  const newGameState = {
+    words: newWords,
+    currentPlayer: newCurrentPlayer,
+    moves: moves + 1,
+    gameOver: false,
+    winner: null,
+    lastLetter: newLastLetter,
+    usedWords: newUsedWords,
+    lastWord: normalizedWord
+  };
+  
+  return { success: true, gameState: newGameState };
+}
+
+// Format word chain for display
+function formatWordChainDisplay(gameState) {
+  const { words, currentPlayer, moves, lastLetter, lastWord } = gameState;
+  
+  let display = `🔗 **Word Chain** (${moves} words)\n\n`;
+  
+  if (words.length === 0) {
+    display += '**Start the chain with any word!**\n\n';
+    display += 'Next: **Player 1**';
+  } else {
+    // Show the chain
+    display += '**Chain:** ' + words.map(w => w.charAt(0).toUpperCase() + w.slice(1)).join(' → ') + '\n\n';
+    
+    if (lastLetter) {
+      display += `**Next word must start with: "${lastLetter.toUpperCase()}"**\n\n`;
+    }
+    
+    display += `Turn: **${currentPlayer === 'player1' ? 'Player 1' : 'Player 2'}**`;
+    
+    if (lastWord) {
+      display += `\nLast word: "${lastWord.charAt(0).toUpperCase() + lastWord.slice(1)}"`;
+    }
+  }
+  
+  return display;
+}
+
+// Check if a letter is considered "difficult" (fewer common words start with it)
+function isDifficultLetter(letter) {
+  const difficultLetters = ['x', 'z', 'q', 'j', 'v'];
+  return difficultLetters.includes(letter.toLowerCase());
+}
+
+module.exports = {
+  createInitialWordChainState,
+  makeMove,
+  formatWordChainDisplay,
+  isValidWord,
+  isDifficultLetter
+};

package/index.js

@@ -6,11 +6,18 @@
  * Identity, presence, DM. That's it.
  */
 
+// Handle "setup" command - redirect to setup.js
+if (process.argv.includes('setup')) {
+  require('./setup.js');
+  return;
+}
+
 const presence = require('./presence');
 const config = require('./config');
 const store = require('./store');
 const prompts = require('./prompts');
 const NotificationEmitter = require('./notification-emitter');
+const authStore = require('./auth-store');
 
 // Tools that shouldn't show presence footer (would be redundant/noisy)
 const SKIP_FOOTER_TOOLS = ['vibe_init', 'vibe_doctor', 'vibe_test', 'vibe_update', 'vibe_settings', 'vibe_notifications'];
@@ -36,9 +43,6 @@ function inferPromptFromArgs(toolName, args) {
     case 'context': return 'share context';
     case 'summarize': return 'summarize session';
     case 'bye': return 'end session';
-    case 'remember': return `remember about ${handle}`;
-    case 'recall': return `recall ${handle}`;
-    case 'forget': return `forget ${handle}`;
     case 'board': return args.content ? 'post to board' : 'view board';
     case 'observe': return args.content ? 'record observation' : 'view observations';
     case 'invite': return 'generate invite';
@@ -50,19 +54,19 @@ function inferPromptFromArgs(toolName, args) {
     case 'release': return `release ${args.reservation_id || 'reservation'}`;
     case 'reservations': return 'list reservations';
     case 'solo_game': return `play ${args.game || 'game'}`;
-    case 'tictactoe': return `play tic-tac-toe ${args.difficulty || ''}`.trim();
-    case 'wordassociation': return args.word ? `word association: ${args.word}` : 'play word association';
+    case 'game': return `play ${args.game || 'game'} with ${handle}`;
     case 'multiplayer_game': return `multiplayer ${args.game || 'game'}`;
     case 'drawing': return args.action ? `drawing ${args.action}` : 'collaborative drawing';
     case 'crossword': return `crossword ${args.action || 'daily'}`;
-    case 'away': return args.message ? `set away: "${args.message}"` : 'go away';
-    case 'back': return 'come back';
     case 'discover': return `discover ${args.command || 'suggest'}`;
     case 'suggest_tags': return `suggest tags ${args.command || 'suggest'}`;
-    case 'skills_exchange': return `skills exchange ${args.command || 'browse'}`;
-    case 'workshop_buddy': return `workshop buddy ${args.command || 'find'}`;
+    case 'settings': return args.mute ? `mute for ${args.mute}` : 'view settings';
     case 'create_artifact': return `create ${args.template || 'artifact'}: ${args.title || 'untitled'}`;
     case 'view_artifact': return args.slug ? `view artifact ${args.slug}` : `list ${args.list || 'artifacts'}`;
+    case 'broadcast': return args.action ? `broadcast ${args.action}` : 'broadcast status';
+    case 'watch': return args.target ? `watch ${args.target}` : 'list live broadcasts';
+    case 'session': return args.action ? `session ${args.action}` : 'list sessions';
+    case 'chat': return args.message ? `chat "${args.message.slice(0, 30)}..."` : 'view chat';
     default: return `${action} ${handle}`.trim() || null;
   }
 }
@@ -164,45 +168,42 @@ async function getPresenceFooter() {
   }
 }
 
-// Load all tools
-const tools = {
+// Load core tools (always available)
+const coreTools = {
   // Entry point
   vibe_start: require('./tools/start'),
   // Core
   vibe_init: require('./tools/init'),
-  vibe_token: require('./tools/token'),  // Privy OAuth token setter
+  vibe_token: require('./tools/token'),  // GitHub OAuth token setter
   vibe_migrate: require('./tools/migrate'),  // Migrate existing handle to GitHub auth
   vibe_who: require('./tools/who'),
   vibe_ping: require('./tools/ping'),
   vibe_react: require('./tools/react'),
   vibe_dm: require('./tools/dm'),
+  vibe_reply: require('./tools/reply'),  // Quick reply to most recent unread
   vibe_inbox: require('./tools/inbox'),
+  vibe_search_messages: require('./tools/search-messages'),  // Search DM history
+  vibe_connection_status: require('./tools/connection-status'),  // Check connection health
+  vibe_smart_check: require('./tools/smart-check'),  // Smart inbox check at natural breaks
   vibe_open: require('./tools/open'),
   vibe_status: require('./tools/status'),
   vibe_context: require('./tools/context'),
+  vibe_work_summary: require('./tools/work-summary'),  // Ambient context for composing messages
   vibe_summarize: require('./tools/summarize'),
   vibe_bye: require('./tools/bye'),
   vibe_game: require('./tools/game'),
   vibe_solo_game: require('./tools/solo-game'),
   vibe_party_game: require('./tools/party-game'),
-  vibe_tictactoe: require('./tools/tictactoe'),
-  vibe_wordassociation: require('./tools/wordassociation'),
   vibe_multiplayer_game: require('./tools/multiplayer-game'),
   vibe_drawing: require('./tools/drawing'),
-  // Nostalgia Stack
   vibe_crossword: require('./tools/crossword'),
-  vibe_away: require('./tools/away'),
-  vibe_back: require('./tools/back'),
   // AIRC Handoff (v1) — context portability
   vibe_handoff: require('./tools/handoff'),
   // File reservations (advisory locks)
   vibe_reserve: require('./tools/reserve'),
   vibe_release: require('./tools/release'),
   vibe_reservations: require('./tools/reservations'),
-  // Memory tools (Tier 1 — Collaborative Memory)
-  vibe_remember: require('./tools/remember'),
-  vibe_recall: require('./tools/recall'),
-  vibe_forget: require('./tools/forget'),
+  // Memory tools removed — simplified UX
   // Consent (AIRC compliance)
   vibe_consent: require('./tools/consent'),
   // Trust & Safety
@@ -220,20 +221,25 @@ const tools = {
   vibe_ship: require('./tools/ship'),
   vibe_feed: require('./tools/feed'),
   vibe_insights: require('./tools/insights'),
+  // Launch Analytics — Real-time metrics dashboard
+  vibe_analytics: require('./tools/analytics'),
+  // Activity Feed — Real-time community activity
+  vibe_activity: require('./tools/activity'),
   // Artifacts — Just-in-time social objects
   vibe_create_artifact: require('./tools/artifact-create'),
   vibe_view_artifact: require('./tools/artifact-view'),
+  // Plans — Async approval workflow
+  vibe_plan: require('./tools/plan'),
+  vibe_approve: require('./tools/approve'),
   // Discovery & Matchmaking
   vibe_discover: require('./tools/discover'),
   vibe_suggest_tags: require('./tools/suggest-tags'),
-  vibe_skills_exchange: require('./tools/skills-exchange'),
-  vibe_workshop_buddy: require('./tools/workshop-buddy'),
-  // Admin tools
-  vibe_admin_inbox: require('./tools/admin-inbox'),
-  // Diagnostics
-  vibe_test: require('./tools/test'),
-  vibe_doctor: require('./tools/doctor'),
-  vibe_update: require('./tools/update'),
+  // Follow system
+  vibe_follow: require('./tools/follow'),
+  // GitHub friends import (Plaxo move)
+  vibe_friends: require('./tools/friends'),
+  // Scheduling
+  vibe_schedule: require('./tools/schedule'),
   // @echo feedback agent (by Flynn)
   vibe_echo: require('./tools/echo'),
   // X/Twitter bridge
@@ -242,29 +248,62 @@ const tools = {
   // Unified social inbox (Phase 1a)
   vibe_social_inbox: require('./tools/social-inbox'),
   vibe_social_post: require('./tools/social-post'),
-  // Language evolution
-  vibe_patterns: require('./tools/patterns'),
   // Settings
   vibe_settings: require('./tools/settings'),
   // External notification channels
   vibe_notifications: require('./tools/notifications'),
   // Background presence agent (Claude Code 2.1)
   vibe_presence_agent: require('./tools/presence-agent'),
-  vibe_mute: require('./tools/mute'),
   // Onboarding checklist
   vibe_onboarding: require('./tools/onboarding'),
   // VIBE L2 tools
   vibe_l2: require('./tools/l2'),
   vibe_l2_status: require('./tools/l2-status'),
   vibe_shipback: require('./tools/shipback'),
-  vibe_bridge: require('./tools/l2-bridge')
+  vibe_bridge: require('./tools/l2-bridge'),
+  // Gig Marketplace & Proof-of-Work
+  vibe_gig_browse: require('./tools/gig-browse'),
+  vibe_gig_complete: require('./tools/gig-complete'),
+  vibe_proof_of_work: require('./tools/proof-of-work'),
+  vibe_artifacts_price: require('./tools/artifacts-price'),
+  // Watch Me Code — Live broadcasting & sessions
+  vibe_broadcast: require('./tools/broadcast'),
+  vibe_watch: require('./tools/watch'),
+  vibe_session: require('./tools/session'),
+  vibe_chat: require('./tools/chat'),
+  // Help Signal — Symbiosis layer
+  vibe_stuck: require('./tools/stuck'),
+  // Availability — Signal openness to chat
+  vibe_available: require('./tools/available'),
+  // VIBE Economy — Tips, Earnings, Withdrawals, Subscriptions
+  vibe_tip: require('./tools/tip'),
+  vibe_earnings: require('./tools/earnings'),
+  vibe_withdraw: require('./tools/withdraw'),
+  vibe_session_price: require('./tools/session_price'),
+  vibe_subscribe: require('./tools/subscribe'),
+  vibe_subscriptions: require('./tools/subscriptions')
 };
 
+// Admin tools (only loaded when VIBE_ADMIN=true)
+const adminTools = process.env.VIBE_ADMIN === 'true' ? {
+  vibe_admin_inbox: require('./tools/admin-inbox'),
+  vibe_test: require('./tools/test'),
+  vibe_doctor: require('./tools/doctor'),
+  vibe_update: require('./tools/update'),
+  vibe_patterns: require('./tools/patterns'),
+} : {};
+
+// Combine tools
+const tools = { ...coreTools, ...adminTools };
+
 /**
  * MCP Protocol Handler
  */
 class VibeMCPServer {
   constructor() {
+    // Hydrate auth state from disk FIRST (before any tools need it)
+    authStore.hydrate();
+
     // Initialize notification emitter
     this.notifier = new NotificationEmitter(this);
 
@@ -345,9 +384,10 @@ class VibeMCPServer {
           // Emit list_changed notification for state-changing tools
           // This triggers Claude to refresh without reconnection
           const stateChangingTools = [
-            'vibe_dm', 'vibe_ping', 'vibe_react', 'vibe_remember',
+            'vibe_dm', 'vibe_ping', 'vibe_react',
             'vibe_status', 'vibe_context', 'vibe_handoff',
-            'vibe_reserve', 'vibe_release'
+            'vibe_reserve', 'vibe_release',
+            'vibe_broadcast', 'vibe_session', 'vibe_chat'
           ];
           if (stateChangingTools.includes(params.name)) {
             // Debounced notification (prevents spam)
@@ -360,29 +400,13 @@ class VibeMCPServer {
             footer = await getPresenceFooter();
           }
 
-          // Build simplified hint indicator for Claude (human-readable)
-          let hintIndicator = '';
-          if (result.hint) {
-            // Simple format: <!-- vibe: hint_type @handle (count) -->
-            const hint = result.hint;
-            const handle = result.suggestion?.handle || result.for_handle || '';
-            const count = result.unread_count || '';
-
-            // Build minimal hint string
-            let hintParts = [hint];
-            if (handle) hintParts.push(`@${handle.replace('@', '')}`);
-            if (count) hintParts.push(`(${count})`);
-
-            hintIndicator = `\n\n<!-- vibe: ${hintParts.join(' ')} -->`;
-          }
-
           return {
             jsonrpc: '2.0',
             id,
             result: {
               content: [{
                 type: 'text',
-                text: (result.display || JSON.stringify(result, null, 2)) + hintIndicator + footer
+                text: (result.display || JSON.stringify(result, null, 2)) + footer
               }]
             }
           };
@@ -443,7 +467,7 @@ class VibeMCPServer {
 
   async checkForUpdates() {
     try {
-      const { checkForUpdates, formatUpdateNotification } = await import('./auto-update.js');
+      const { checkForUpdates, formatUpdateNotification } = require('./auto-update');
       const update = await checkForUpdates();
 
       if (update) {

package/intelligence/index.js

@@ -1,17 +1,19 @@
 /**
  * Intelligence Module — Ambient Social Awareness
  *
- * Four layers of intelligence:
+ * Five layers of intelligence:
  * 1. Infer — Smart state detection from context signals
  * 2. Serendipity — Surface meaningful coincidences
  * 3. Proactive — Background agent for social moments
  * 4. Patterns — Persistent behavioral memory (work, social, creative)
+ * 5. Interests — Live interest inference from context (Phase 2)
  */
 
 const infer = require('./infer');
 const serendipity = require('./serendipity');
 const proactive = require('./proactive');
 const patterns = require('./patterns');
+const interests = require('./interests');
 
 module.exports = {
   // Inference
@@ -34,5 +36,10 @@ module.exports = {
   setSessionStart: proactive.setSessionStart,
 
   // Patterns (persistent behavioral memory)
-  patterns
+  patterns,
+
+  // Interests (live context inference - Phase 2)
+  inferLiveInterests: interests.inferLiveInterests,
+  mergeInterests: interests.mergeInterests,
+  formatLiveInterests: interests.formatLiveInterests
 };