slashvibe-mcp 0.2.8 → 0.3.13

package/tools/inbox.js

@@ -5,47 +5,118 @@
 const config = require('../config');
 const store = require('../store');
 const notify = require('../notify');
-const analytics = require('../analytics');
-const { requireInit, header, emptyState, formatTimeAgo, truncate, divider } = require('./_shared');
+const patterns = require('../intelligence/patterns');
+const { formatPayload } = require('../protocol');
+const { requireInit, header, emptyState, formatTimeAgo, truncate, divider, fetchRelevantUsers } = require('./_shared');
 const { actions, formatActions } = require('./_actions');
 
-// Helper: Fetch recent ships for social proof (FOMO)
-async function getRecentShips(limit = 2) {
-  try {
-    const apiUrl = config.getApiUrl();
-    const response = await fetch(`${apiUrl}/api/board?limit=${limit}&category=shipped`);
-    const data = await response.json();
-    return (data.entries || []).map(e => ({
-      author: e.author,
-      content: e.content?.slice(0, 50)
-    }));
-  } catch (e) {
-    return [];
-  }
+// Truncate message for preview (first 100 chars, clean break at word)
+function summarizeMessage(text, maxLen = 100) {
+  if (!text || text.length <= maxLen) return text;
+  const truncated = text.slice(0, maxLen);
+  const lastSpace = truncated.lastIndexOf(' ');
+  return (lastSpace > maxLen * 0.7 ? truncated.slice(0, lastSpace) : truncated) + '...';
 }
 
-// Helper: Get next incomplete onboarding task
-async function getNextOnboardingTask(handle) {
+// Get activity heat icon for a user (borrowed from who.js logic)
+function getStatusIcon(user) {
+  if (!user) return '●';
+
+  // Check mood/status
+  if (user.mood === '🔥' || user.mood === '🚀' || user.builderMode === 'shipping') return '🔥';
+  if (user.mood === '🧠' || user.builderMode === 'deep-focus') return '🧠';
+  if (user.mood === '🐛') return '🐛';
+  if (user.mood === '🌙') return '🌙';
+
+  // Check recency
+  const lastSeenMs = user.lastSeen || Date.now();
+  const minutesAgo = (Date.now() - lastSeenMs) / 60000;
+  if (minutesAgo < 5) return '⚡';
+  if (minutesAgo < 30) return '●';
+  return '○';
+}
+
+// Get status label for a user
+function getStatusLabel(user) {
+  if (!user) return null;
+
+  if (user.mood === '🔥' || user.mood === '🚀' || user.builderMode === 'shipping') return 'shipping';
+  if (user.mood === '🧠' || user.builderMode === 'deep-focus') return 'deep focus';
+  if (user.mood === '🐛') return 'debugging';
+  if (user.mood === '🌙') return 'late night';
+  if (user.mood === '💭') return 'thinking';
+
+  const lastSeenMs = user.lastSeen || Date.now();
+  const minutesAgo = (Date.now() - lastSeenMs) / 60000;
+  if (minutesAgo < 5) return 'active';
+  if (minutesAgo < 30) return 'online';
+  return 'away';
+}
+
+// Build recommended connections display for empty/caught-up inbox
+async function buildRecommendationsDisplay(myHandle) {
+  // Fetch recommendations from relevancy API
+  const relevancy = await fetchRelevantUsers(myHandle, 'dm_suggest', 5);
+
+  if (!relevancy || !relevancy.matches || relevancy.matches.length === 0) {
+    return null; // Fallback to old behavior
+  }
+
+  const matches = relevancy.matches;
+
+  // Get presence info for status display
+  const presenceMap = new Map();
   try {
-    const checklist = await store.getChecklistStatus(handle);
-    if (checklist.success && checklist.tasks) {
-      const nextTask = checklist.tasks.find(t => !t.done);
-      if (nextTask) {
-        // Map task IDs to user-friendly actions
-        const taskActions = {
-          'read_welcome': { shortLabel: 'Read welcome', command: 'check my messages', description: 'See your welcome message' },
-          'reply_seth': { shortLabel: 'Reply to @vibe', command: 'message @vibe', description: 'Say hi back!' },
-          'message_builder': { shortLabel: 'Message a builder', command: 'discover suggest', description: 'Find someone to connect with' },
-          'post_ship': { shortLabel: 'Ship something', command: 'ship what I built', description: 'Share what you\'re building' },
-          'leave_feedback': { shortLabel: 'Give feedback', command: 'talk to @echo', description: 'Help improve /vibe' }
-        };
-        return taskActions[nextTask.id] || null;
-      }
-    }
-    return null;
+    const presence = await store.getPresence();
+    const allUsers = [...(presence.active || []), ...(presence.away || [])];
+    allUsers.forEach(u => {
+      presenceMap.set(u.handle?.toLowerCase(), u);
+    });
   } catch (e) {
-    return null;
+    // Continue without presence info
   }
+
+  // Build preview line (stays visible when collapsed)
+  const top3Handles = matches.slice(0, 3).map(m => `@${m.handle}`).join(', ');
+  let display = `📭 All caught up! Connect with: ${top3Handles}\n\n`;
+
+  // Build ranked list with statuses
+  display += `---\n`;
+
+  matches.forEach(match => {
+    const presenceUser = presenceMap.get(match.handle?.toLowerCase());
+    const icon = getStatusIcon(presenceUser);
+    const statusLabel = getStatusLabel(presenceUser);
+    const statusText = statusLabel ? ` — ${statusLabel}` : '';
+
+    display += `${icon} **@${match.handle}**${statusText}\n`;
+
+    // Show building + first reason
+    if (match.building) {
+      const reason = match.reasons?.[0] ? ` • ${match.reasons[0]}` : '';
+      display += `   "${summarizeMessage(match.building, 50)}"${reason}\n`;
+    } else if (match.reasons?.[0]) {
+      display += `   ${match.reasons[0]}\n`;
+    }
+
+    display += '\n';
+  });
+
+  // Enrich matches with status info for action descriptions
+  const enrichedMatches = matches.map(match => {
+    const presenceUser = presenceMap.get(match.handle?.toLowerCase());
+    return {
+      ...match,
+      statusIcon: getStatusIcon(presenceUser),
+      statusLabel: getStatusLabel(presenceUser)
+    };
+  });
+
+  return {
+    display,
+    matches: enrichedMatches,
+    actions: formatActions(actions.recommendedConnections(enrichedMatches))
+  };
 }
 
 const definition = {
@@ -68,49 +139,72 @@ async function handler(args) {
   notify.checkAll(store);
 
   if (!threads || threads.length === 0) {
-    // Fetch context for retention-optimized actions (parallel for speed)
-    const [recentShips, onboardingTask] = await Promise.all([
-      getRecentShips(2),
-      getNextOnboardingTask(myHandle)
-    ]);
-
-    // Build social proof line
-    let socialProof = '';
-    if (recentShips.length > 0) {
-      socialProof = `\n   💫 @${recentShips[0].author} just shipped`;
+    // Try to show personalized recommendations
+    try {
+      const recommendations = await buildRecommendationsDisplay(myHandle);
+      if (recommendations) {
+        // Change preview line for empty inbox (no messages yet)
+        const display = recommendations.display.replace(
+          'All caught up!',
+          'No messages yet.'
+        );
+        return {
+          display,
+          actions: recommendations.actions
+        };
+      }
+    } catch (e) {
+      console.log('[inbox] recommendations error:', e.message);
     }
 
-    // Build CTA based on onboarding state
-    let cta = onboardingTask
-      ? `→ ${onboardingTask.shortLabel}: "${onboardingTask.command}"`
-      : 'Say "dm @someone" to start';
-
-    // Track empty inbox state for retention analytics
-    analytics.trackEmptyInbox('none', {
-      recentThreads: [],
-      recentShips,
-      onboardingTask,
-      state: 'no_messages'
-    });
+    // Fallback: Check onboarding status to customize CTA
+    let cta = 'Say "dm @someone" to start';
+    try {
+      const checklist = await store.getChecklistStatus(myHandle);
+      if (checklist.success && checklist.tasks) {
+        const repliedToSeth = checklist.tasks.find(t => t.id === 'reply_seth')?.done;
+        if (!repliedToSeth) {
+          cta = 'Reply to @vibe to get started!';
+        }
+      }
+    } catch (e) {}
 
     return {
-      display: `── 📭 Inbox ──────────────────────────
-   No messages yet${socialProof}
-   ${cta}
-──────────────────────────────────────`,
-      hint: 'suggest_compose',
-      actions: formatActions(actions.emptyInbox({
-        recentThreads: [],
-        recentShips,
-        onboardingTask
-      }))
+      display: `📭 No messages yet. ${cta}`,
+      actions: formatActions(actions.recommendedConnections([]))
     };
   }
 
-  // Sort: unread first, then by most recent
+  // Fetch relevant users to prioritize notifications
+  // Messages from relevant users appear first within unread threads
+  const relevantHandles = new Map(); // handle -> relevancy score (position in matches)
+  try {
+    const relevancy = await fetchRelevantUsers(myHandle, 'notification', 20);
+    if (relevancy && relevancy.matches) {
+      relevancy.matches.forEach((m, idx) => {
+        // Higher score = more relevant (inverse of position)
+        relevantHandles.set(m.handle.toLowerCase(), relevancy.matches.length - idx);
+      });
+    }
+  } catch (e) {
+    // Don't fail inbox if relevancy fails
+    console.log('[inbox] relevancy fetch error:', e.message);
+  }
+
+  // Sort: unread first, then by relevancy within unread, then by most recent
   const sorted = threads.sort((a, b) => {
+    // Primary: unread vs read
     if (a.unread > 0 && b.unread === 0) return -1;
     if (b.unread > 0 && a.unread === 0) return 1;
+
+    // Secondary (within same read/unread status): relevancy
+    const aRelevancy = relevantHandles.get(a.handle.toLowerCase()) || 0;
+    const bRelevancy = relevantHandles.get(b.handle.toLowerCase()) || 0;
+    if (aRelevancy !== bRelevancy) {
+      return bRelevancy - aRelevancy; // Higher relevancy first
+    }
+
+    // Tertiary: timestamp (most recent first)
     return (b.lastTimestamp || 0) - (a.lastTimestamp || 0);
   });
 
@@ -119,51 +213,141 @@ async function handler(args) {
 
   // Handle case where all messages are read (no unread)
   if (totalUnread === 0) {
-    const recentHandles = sorted.slice(0, 3).map(t => t.handle);
-    const recentDisplay = recentHandles.map(h => `@${h}`).join(', ');
-
-    // Fetch context for retention-optimized actions (parallel for speed)
-    const [recentShips, onboardingTask] = await Promise.all([
-      getRecentShips(2),
-      getNextOnboardingTask(myHandle)
-    ]);
-
-    // Build social proof line
-    let socialProof = '';
-    if (recentShips.length > 0) {
-      socialProof = `\n   💫 @${recentShips[0].author} just shipped`;
+    // Try to show personalized recommendations
+    try {
+      const recommendations = await buildRecommendationsDisplay(myHandle);
+      if (recommendations) {
+        return {
+          display: recommendations.display,
+          actions: recommendations.actions
+        };
+      }
+    } catch (e) {
+      console.log('[inbox] recommendations error:', e.message);
     }
 
-    // Track empty inbox state for retention analytics
-    analytics.trackEmptyInbox('none', {
-      recentThreads: recentHandles,
-      recentShips,
-      onboardingTask,
-      state: 'all_caught_up'
-    });
-
+    // Fallback: show recent threads
+    const recentHandles = sorted.slice(0, 3).map(t => `@${t.handle}`).join(', ');
     return {
-      display: `── 📭 Inbox ──────────────────────────
-   All caught up! Recent: ${recentDisplay}${socialProof}
-──────────────────────────────────────`,
-      hint: 'suggest_compose',
-      actions: formatActions(actions.emptyInbox({
-        recentThreads: recentHandles,
-        recentShips,
-        onboardingTask
-      }))
+      display: `📭 All caught up! Recent: ${recentHandles}`,
+      actions: formatActions(actions.recommendedConnections([]))
     };
   }
 
-  // Auto-open single unread message (skip inbox view to reduce friction)
+  // Auto-open single unread thread inline (no second tool call needed)
   if (totalUnread === 1 && unreadSenders.length === 1) {
-    const singleSender = unreadSenders[0];
-    return {
-      hint: 'auto_open_single_thread',
-      handle: singleSender.handle,
-      preview: truncate(singleSender.lastMessage || '', 60),
-      display: `📬 Opening thread with @${singleSender.handle}...`
-    };
+    const them = unreadSenders[0].handle;
+
+    // Fetch full thread and mark as read
+    const thread = await store.getThread(myHandle, them);
+    await store.markThreadRead(myHandle, them);
+
+    // Auto-track readWelcomeAt if viewing welcome from @seth
+    const isWelcomeThread = them.toLowerCase() === 'seth';
+    if (isWelcomeThread) {
+      try {
+        await store.trackChecklistCompletion(myHandle, 'read_welcome', {
+          source: 'inbox_auto_open',
+          timestamp: Date.now()
+        });
+        console.log('[inbox] Auto-tracked readWelcomeAt for', myHandle);
+      } catch (e) {
+        console.warn('[inbox] Failed to track readWelcomeAt:', e.message);
+      }
+    }
+
+    // Log received messages for patterns
+    const theirMessages = thread.filter(m => m.from === them);
+    if (theirMessages.length > 0) {
+      patterns.logMessageReceived(them);
+    }
+
+    // Check if they're typing
+    let typingNotice = '';
+    try {
+      const typingUsers = await store.getTypingUsers(myHandle);
+      if (typingUsers.includes(them)) {
+        typingNotice = `\n_@${them} is typing..._\n`;
+      }
+    } catch (e) {}
+
+    // Build thread display - summary first, newest-first thread
+    const latestFromThem = theirMessages.length > 0
+      ? theirMessages.sort((a, b) => (b.timestamp || 0) - (a.timestamp || 0))[0]
+      : null;
+
+    let display = '';
+
+    if (latestFromThem) {
+      const agentBadge = latestFromThem.isAgent ? ' 🤖' : '';
+      const time = store.formatTimeAgo(latestFromThem.timestamp);
+      const preview = latestFromThem.body
+        ? summarizeMessage(latestFromThem.body)
+        : (latestFromThem.payload ? '[attachment]' : '');
+
+      display = `💬 @${them}${agentBadge} (${time}): "${preview}"\n\n`;
+    } else {
+      display = `💬 @${them}: _Waiting for reply..._\n\n`;
+    }
+
+    // Thread section - sorted newest first
+    display += `---\n📜 Thread\n\n`;
+
+    const sortedThread = [...thread].sort((a, b) => (b.timestamp || 0) - (a.timestamp || 0));
+
+    sortedThread.forEach(m => {
+      const isMe = m.from === myHandle;
+      const agentBadge = m.isAgent && !isMe ? '🤖 ' : '';
+      const sender = isMe ? 'you' : `@${m.from}`;
+      const time = store.formatTimeAgo(m.timestamp);
+
+      display += `${agentBadge}**${sender}** — _${time}_\n`;
+
+      if (m.body) {
+        display += `${m.body}\n`;
+      }
+
+      if (m.payload) {
+        display += `${formatPayload(m.payload)}\n`;
+      }
+
+      display += '\n';
+    });
+
+    if (typingNotice) {
+      display += typingNotice + '\n';
+    }
+
+    display += `---\nJust type your reply to send it`;
+
+    // For @seth welcome thread, fetch recommended builders and add actions
+    if (isWelcomeThread) {
+      try {
+        const onboardingData = await store.getOnboardingData(myHandle);
+        if (onboardingData.success && onboardingData.recommendedUsers?.length > 0) {
+          // Build action options to message recommended builders
+          const recommendedActions = onboardingData.recommendedUsers.slice(0, 3).map(user => {
+            const description = user.workingOn
+              ? `Building: "${truncate(user.workingOn, 40)}"`
+              : 'Recommended for you';
+            return {
+              handle: user.handle,
+              building: user.workingOn,
+              reasons: ['Matched during your welcome']
+            };
+          });
+
+          return {
+            display,
+            actions: formatActions(actions.recommendedConnections(recommendedActions))
+          };
+        }
+      } catch (e) {
+        console.warn('[inbox] Failed to fetch recommended builders:', e.message);
+      }
+    }
+
+    return { display };
   }
 
   // Build compact display (3 lines above the fold)

package/tools/init.js

@@ -16,6 +16,7 @@ const path = require('path');
 const config = require('../config');
 const store = require('../store');
 const discord = require('../discord');
+const authStore = require('../auth-store');
 
 const CALLBACK_PORT = 9876;
 const API_BASE = 'https://www.slashvibe.dev';
@@ -143,15 +144,34 @@ function detectTechStack() {
 }
 
 /**
- * Send personalized welcome from @vibe (non-blocking)
+ * Fetch GitHub friends who are on /vibe (non-blocking)
+ */
+async function fetchGitHubFriends(handle) {
+  try {
+    const response = await fetch(`${API_BASE}/api/github/contacts?handle=${encodeURIComponent(handle)}`);
+    if (!response.ok) return null;
+    const data = await response.json();
+    if (!data.success) return null;
+    return {
+      friendsOnVibe: data.people_you_know?.slice(0, 5) || [],
+      inviteSuggestions: data.invite_suggestions?.slice(0, 10) || [],
+      totalContacts: data.stats?.total_contacts || 0
+    };
+  } catch (e) {
+    return null;
+  }
+}
+
+/**
+ * Send personalized welcome from @seth
+ * Returns the welcome message content so we can show it inline
  */
 async function sendPersonalizedWelcome(handle, oneLiner) {
   try {
     const repoName = detectRepoName();
     const techStack = detectTechStack();
 
-    // Fire and forget - don't block init completion
-    fetch(`${API_BASE}/api/onboarding/personalized-welcome`, {
+    const response = await fetch(`${API_BASE}/api/onboarding/personalized-welcome`, {
       method: 'POST',
       headers: { 'Content-Type': 'application/json' },
       body: JSON.stringify({
@@ -159,14 +179,20 @@ async function sendPersonalizedWelcome(handle, oneLiner) {
         oneLiner,
         repoName,
         techStack,
-        githubProfile: null  // Could be passed from callback if available
+        githubProfile: null
       })
-    }).catch(e => {
-      console.error('[vibe_init] Personalized welcome failed:', e.message);
     });
+
+    if (!response.ok) {
+      console.error('[vibe_init] Welcome API error:', response.status);
+      return null;
+    }
+
+    const result = await response.json();
+    return result.success ? result : null;
   } catch (e) {
-    // Non-fatal - continue without personalized welcome
-    console.error('[vibe_init] Context detection failed:', e.message);
+    console.error('[vibe_init] Personalized welcome failed:', e.message);
+    return null;
   }
 }
 
@@ -175,7 +201,7 @@ const API_URL = process.env.VIBE_API_URL || 'https://www.slashvibe.dev';
 const AUTH_TIMEOUT_MS = 120000; // 2 minutes
 
 /**
- * Send welcome message from @vibe
+ * Send welcome message from @seth (founder)
  */
 async function sendWelcomeMessage(handle, one_liner) {
   try {
@@ -252,10 +278,15 @@ function waitForCallback(requestedHandle, one_liner) {
           // Save the token and handle
           const finalHandle = requestedHandle || callbackHandle;
 
-          // Save to config
-          config.savePrivyToken(token);
+          // Save to config (file persistence for restarts)
+          config.saveAuthToken(token);
           config.setSessionIdentity(finalHandle, one_liner || '');
 
+          // PUSH to in-memory auth store (immediate propagation)
+          authStore.setToken(token);
+          authStore.setHandle(finalHandle);
+          authStore.setOneLiner(one_liner || '');
+
           // Update shared config
           const cfg = config.load();
           cfg.handle = finalHandle;
@@ -274,8 +305,8 @@ function waitForCallback(requestedHandle, one_liner) {
           // Post to Discord
           discord.postJoin(finalHandle, one_liner);
 
-          // Send personalized welcome from @vibe (non-blocking)
-          sendPersonalizedWelcome(finalHandle, one_liner);
+          // NOTE: Welcome message is sent in the main return path (awaited)
+          // to ensure it arrives before we show the unread count
 
           // Send success response to browser - lightweight, no infinite animations
           res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' });
@@ -562,7 +593,7 @@ async function handler(args) {
   }
 
   // Check if already authenticated
-  if (config.hasPrivyAuth()) {
+  if (config.hasOAuth()) {
     const existingHandle = config.getHandle();
     if (existingHandle) {
       return {
@@ -605,24 +636,63 @@ To check messages: \`vibe inbox\``
       // Wait for callback (blocks until auth completes or times out)
       const result = await waitForCallback(h, one_liner);
 
-      // Check for unread messages
-      let unreadNotice = '';
+      // Send personalized welcome and wait for it (2.5s timeout)
+      let welcomeResult = null;
       try {
-        const unreadCount = await store.getUnreadCount(result.handle);
-        if (unreadCount > 0) {
-          unreadNotice = `\n\n📬 **${unreadCount} unread messages** — say "check my messages"`;
-        }
+        welcomeResult = await Promise.race([
+          sendPersonalizedWelcome(result.handle, one_liner),
+          new Promise(resolve => setTimeout(() => resolve(null), 2500))
+        ]);
+      } catch (e) {
+        console.error('[vibe_init] Welcome message failed:', e.message);
+      }
+
+      // Check for unread messages (includes the welcome we just sent)
+      let unreadCount = 0;
+      try {
+        unreadCount = await store.getUnreadCount(result.handle);
+      } catch (e) {}
+
+      // Fetch GitHub friends (non-blocking, 3s timeout)
+      let friendsData = null;
+      try {
+        const friendsPromise = fetchGitHubFriends(result.handle);
+        friendsData = await Promise.race([
+          friendsPromise,
+          new Promise(resolve => setTimeout(() => resolve(null), 3000))
+        ]);
       } catch (e) {}
 
       // Generate authenticated banner with handle + unread (3 lines only - won't collapse)
-      const authBanner = generateAuthBanner(result.handle, 1, onlineCount);
+      const authBanner = generateAuthBanner(result.handle, unreadCount, onlineCount);
+
+      // Build friends section if we have data
+      let friendsSection = '';
+      if (friendsData?.friendsOnVibe?.length > 0) {
+        const friendHandles = friendsData.friendsOnVibe.map(f => `@${f.vibe_handle}`).join(', ');
+        friendsSection = `\n\n🤝 **${friendsData.friendsOnVibe.length} of your GitHub friends are here!**\n${friendHandles}`;
+      } else if (friendsData?.totalContacts > 0) {
+        friendsSection = `\n\n👋 None of your GitHub friends are on /vibe yet — say **"vibe invite"** to bring them in!`;
+      }
+
+      // Build welcome section - show inline if we have the message
+      let welcomeSection = '';
+      if (welcomeResult?.messageText) {
+        welcomeSection = `\n\n---\n**📨 Welcome message from @seth:**\n\n> ${welcomeResult.messageText.split('\n').join('\n> ')}\n\n_Reply with **"vibe dm @seth [message]"** to say hi!_`;
+      } else {
+        welcomeSection = '\n\n---\n**📨 @seth sent you a welcome message!**\n\nSay **"vibe inbox"** to read it and get started.';
+      }
 
       return {
-        display: authBanner,
+        display: authBanner + friendsSection + welcomeSection,
         onboarding: {
           isNewUser: true,
           handle: result.handle,
-          hint: 'show_onboarding_options'
+          hint: 'show_onboarding_options',
+          hasWelcomeMessage: !!welcomeResult,
+          welcomeText: welcomeResult?.messageText || null,
+          friendsOnVibe: friendsData?.friendsOnVibe || [],
+          inviteSuggestions: friendsData?.inviteSuggestions || []
         }
       };
 
@@ -700,7 +770,16 @@ Local config saved. Heartbeats will use username fallback.`
   discord.postJoin(h, one_liner);
 
   // Send personalized welcome from @vibe (non-blocking)
-  sendPersonalizedWelcome(h, one_liner);
+  // Send personalized welcome and wait for it
+  let welcomeResult = null;
+  try {
+    welcomeResult = await Promise.race([
+      sendPersonalizedWelcome(h, one_liner),
+      new Promise(resolve => setTimeout(() => resolve(null), 2500))
+    ]);
+  } catch (e) {
+    console.error('[vibe_init] Welcome message failed:', e.message);
+  }
 
   // Check for unread messages
   let unreadNotice = '';
@@ -718,14 +797,14 @@ Local config saved. Heartbeats will use username fallback.`
 **@${h}**
 _${one_liner}_${unreadNotice}${keypairNote}
 
-📨 **Check your messages** — @vibe sent you a personalized welcome!
+📨 **Check your messages** — @seth sent you a personalized welcome!
 
 ⚠️ **Using local keys** — consider upgrading to GitHub auth:
 \`vibe init\` — Sign in with GitHub for verified identity
 
 ### Onboarding Checklist
-[ ] Read your welcome message from @vibe
-[ ] Reply to @vibe
+[ ] Read your welcome message from @seth
+[ ] Reply to @seth
 [ ] Message one recommended builder
 [ ] Post your first ship
 [ ] Leave some feedback