slashvibe-mcp 0.8.23 → 0.8.25

package/index.js

@@ -658,6 +658,7 @@ class VibeMCPServer {
           // The HTTP store creates one random key per logical send and preserves it
           // across its internal transport retries. JSON-RPC ids restart every MCP
           // process, so deriving a durable key from `id` would collapse future sends.
+          presence.noteActivity(); // a tool call = the person is here; polls snap back to fast
           const result = await tool.handler(args);
 
           // Emit list_changed notification for state-changing tools

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "slashvibe-mcp",
-  "version": "0.8.23",
+  "version": "0.8.25",
   "mcpName": "io.github.vibecodinginc/vibe",
   "description": "Presence + messaging for terminal coding agents (Claude Code, Codex, Cursor) — the /vibe kernel",
   "main": "index.js",

package/presence.js

@@ -5,7 +5,7 @@
  * Uses session tokens for per-session identity.
  * Users become "idle" after 5 minutes of no heartbeat.
  *
- * Also runs a guest message poll every 15 seconds. When guest messages
+ * Also polls for DMs and guest messages on an idle-aware cadence. When they
  * are detected, emits a tools/list_changed notification to force Claude
  * to re-query vibe tools (which triggers getPresenceFooter and injects
  * the messages into context). This ensures Use Case 2 (user testing/QA)
@@ -18,9 +18,54 @@ const store = require('./store');
 const { apiHeaders } = require('./api-auth');
 
 let heartbeatInterval = null;
-let guestPollInterval = null;
+let unreadPollTimer = null;
+let guestPollTimer = null;
 let sessionInitialized = false;
 
+// ---- Poll cadence (2026-09-02 audit) -------------------------------------
+// One idle signed-in client made 2 inbox reads every 15s forever — session/guest
+// (6 KV commands) + the full threads list (1) — and the fleet's long-lived
+// sessions (9-hour and 9-day-old windows) added up to ~7 inbox polls/sec at
+// the KV. Replies must still land fast, so the DM check stays at 15s while the
+// person is ACTIVE (any tool call in the last ACTIVE_WINDOW_MS) and backs off
+// to 60s when idle; the guest-session poll, a pairing feature almost nobody is
+// in, runs at 60s active / 300s idle. Any tool call snaps both back to fast.
+// Worst-case DM latency: 15s active, 60s idle.
+const ACTIVE_WINDOW_MS = Number(process.env.VIBE_POLL_ACTIVE_WINDOW_MS) || 10 * 60 * 1000;
+const CADENCE = {
+  active: { unread: 15 * 1000, guest: 60 * 1000 },
+  idle:   { unread: 60 * 1000, guest: 300 * 1000 },
+};
+let lastActivityAt = Date.now(); // the session starting is activity
+
+function noteActivity() {
+  const wasIdle = cadenceFor(Date.now() - lastActivityAt) === CADENCE.idle;
+  lastActivityAt = Date.now();
+  // A pending idle timer would still fire on the slow cadence (codex P2 on #37):
+  // re-arm both polls on the fast cadence the moment the person is back.
+  if (wasIdle) {
+    if (unreadPollTimer) { clearTimeout(unreadPollTimer); schedule('unread'); }
+    if (guestPollTimer) { clearTimeout(guestPollTimer); schedule('guest'); }
+  }
+}
+
+/** Pure: which cadence applies after `idleMs` without a tool call. */
+function cadenceFor(idleMs) {
+  return idleMs < ACTIVE_WINDOW_MS ? CADENCE.active : CADENCE.idle;
+}
+
+function schedule(kind) {
+  const ms = cadenceFor(Date.now() - lastActivityAt)[kind];
+  const run = async () => {
+    if (kind === 'unread') await pollUnread(); else await pollGuestMessages();
+    // Re-arm only while start() is in effect (stop() clears the timers).
+    if (kind === 'unread' ? unreadPollTimer : guestPollTimer) schedule(kind);
+  };
+  const t = setTimeout(run, ms);
+  t.unref?.();
+  if (kind === 'unread') unreadPollTimer = t; else guestPollTimer = t;
+}
+
 function start() {
   if (heartbeatInterval) return;
 
@@ -30,11 +75,9 @@ function start() {
   // Then every 30 seconds
   heartbeatInterval = setInterval(sendHeartbeat, 30 * 1000);
 
-  // Guest message poll: every 15 seconds, check for incoming session messages
-  // and emit tools/list_changed to force Claude to pick them up via getPresenceFooter
-  if (!guestPollInterval) {
-    guestPollInterval = setInterval(pollGuestMessages, 15 * 1000);
-  }
+  // Inbox polls on the idle-aware cadence above (see CADENCE).
+  if (!unreadPollTimer) schedule('unread');
+  if (!guestPollTimer) schedule('guest');
 }
 
 function stop() {
@@ -42,9 +85,13 @@ function stop() {
     clearInterval(heartbeatInterval);
     heartbeatInterval = null;
   }
-  if (guestPollInterval) {
-    clearInterval(guestPollInterval);
-    guestPollInterval = null;
+  if (unreadPollTimer) {
+    clearTimeout(unreadPollTimer);
+    unreadPollTimer = null;
+  }
+  if (guestPollTimer) {
+    clearTimeout(guestPollTimer);
+    guestPollTimer = null;
   }
   // Clean up session file
   config.clearSession();
@@ -97,13 +144,11 @@ async function pollGuestMessages() {
   try {
     const handle = config.getHandle();
     if (!handle) return;
-
     const apiUrl = config.getApiUrl?.() || 'https://www.slashvibe.dev';
     const resp = await fetch(`${apiUrl}/api/session/guest?handle=${encodeURIComponent(handle)}`, {
       headers: apiHeaders(),
     });
     if (!resp.ok) return;
-
     const data = await resp.json();
     if (data.success && Array.isArray(data.messages) && data.messages.length > 0) {
       // Guest messages waiting — emit list_changed to force Claude to refresh
@@ -112,11 +157,21 @@ async function pollGuestMessages() {
         global.vibeNotifier.emitImmediate();
       }
     }
+  } catch {
+    // Silent fail — guest polling is best-effort
+  }
+}
 
-    // Ordinary DMs: nudge the session when the unread count RISES, so a DM
-    // sent from any surface reaches the live session within one poll cycle
-    // (getPresenceFooter injects the new bodies, once each). A drop just
-    // rebaselines — reading elsewhere shouldn't trigger a refresh here.
+/**
+ * Ordinary DMs: nudge the session when the unread count RISES, so a DM sent
+ * from any surface reaches the live session within one poll cycle
+ * (getPresenceFooter injects the new bodies, once each). A drop just
+ * rebaselines — reading elsewhere shouldn't trigger a refresh here.
+ */
+async function pollUnread() {
+  try {
+    const handle = config.getHandle();
+    if (!handle) return;
     const unread = await store.getUnreadCount(handle).catch(() => null);
     if (typeof unread === 'number') {
       if (lastSeenUnread !== null && unread > lastSeenUnread && global.vibeNotifier) {
@@ -125,7 +180,7 @@ async function pollGuestMessages() {
       lastSeenUnread = unread;
     }
   } catch {
-    // Silent fail — guest polling is best-effort
+    // Silent fail — best-effort
   }
 }
 
@@ -170,4 +225,8 @@ async function goOffline() {
   }
 }
 
-module.exports = { start, stop, forceHeartbeat, goOffline };
+module.exports = { start, stop, forceHeartbeat, goOffline, noteActivity, cadenceFor, CADENCE, ACTIVE_WINDOW_MS,
+  // test seams — read the armed delays, and age the session without waiting
+  _pollDelaysForTest: () => ({ unread: unreadPollTimer?._idleTimeout ?? null, guest: guestPollTimer?._idleTimeout ?? null }),
+  _setLastActivityForTest: (ts) => { lastActivityAt = ts; },
+};

package/protocol/handle.js

@@ -30,12 +30,14 @@ function canonicalHandle(value) {
   if (typeof value !== 'string') return '';
   let h = value.replace(INVISIBLE, '');
   h = h.normalize ? h.normalize('NFC') : h;
-  h = h.trim().replace(/^@+/, '').trim().toLowerCase();
-  return h.replace(/-/g, '_');
+  // A handle is the GitHub login, and GitHub logins may contain '-'. Rewriting
+  // dashes to underscores made `vibe inbox synth-stan` look up synth_stan and
+  // render an empty thread (found live 2026-09-02). Keep the dash.
+  return h.trim().replace(/^@+/, '').trim().toLowerCase();
 }
 
-/** Platform-legal shape: ASCII letters, digits, underscore. Reject anything else. */
-const isCanonicalHandle = (value) => /^[a-z0-9_]{1,39}$/.test(canonicalHandle(value));
+/** Platform-legal shape: ASCII letters, digits, underscore, dash (GitHub logins). Reject anything else. */
+const isCanonicalHandle = (value) => /^[a-z0-9_-]{1,39}$/.test(canonicalHandle(value));
 
 /** True when two handles refer to the same principal label. */
 const sameHandle = (a, b) => {

package/store/api.js

@@ -797,24 +797,53 @@ async function getRawInbox(handle) {
 
     // Transform threads with unread messages into message-like objects
     // for compatibility with notification system
-    const unreadMessages = [];
-
-    for (const thread of threads) {
-      if (thread.unread > 0 && thread.last_message) {
-        // Create message object from thread's last message
-        unreadMessages.push({
-          id: thread.last_message.id,
-          from: thread.last_message.from,
-          to: handle,
-          text: thread.last_message.body,
-          body: thread.last_message.body,
-          createdAt: thread.last_message.created_at,
-          read: false, // If it's in unread threads, it's unread
-          thread_id: thread.id,
-          unread_count: thread.unread,
-        });
+    const me = String(handle || '').toLowerCase();
+    const isMine = (m) => String(m?.from || '').toLowerCase() === me;
+    const candidates = threads.filter((t) => t.unread > 0 && t.last_message);
+
+    // "Waiting" means THEIR words. When the newest message is mine — I replied
+    // and their earlier message is still unread — the thread's last_message
+    // is my own send, and presenting it as "MESSAGE from @me" told a person
+    // their own words had arrived (Seth, 2026-09-02, the day of the invite).
+    // For those threads read the TAIL of the thread (the API pages oldest-first)
+    // and take the newest message of theirs. Bounded parallelism: the session-
+    // start hook runs this under a 4s deadline (codex P2 ×2 on #38).
+    const TAIL = 50;
+    const resolveWaiting = async (thread) => {
+      if (!isMine(thread.last_message)) return thread.last_message;
+      try {
+        const count = Number(thread.message_count);
+        const offset = Number.isFinite(count) && count > TAIL ? count - TAIL : 0;
+        const t = await request('GET', `/api/v2/threads/${encodeURIComponent(thread.id)}?limit=${TAIL}&offset=${offset}`);
+        const theirs = (t.messages || []).filter((m) => !isMine(m));
+        return theirs.length ? theirs[theirs.length - 1] : null;
+      } catch {
+        return null;
       }
-    }
+    };
+    const CONCURRENCY = 6;
+    const resolved = new Array(candidates.length);
+    let next = 0;
+    await Promise.all(Array.from({ length: Math.min(CONCURRENCY, candidates.length) }, async () => {
+      while (next < candidates.length) { const i = next++; resolved[i] = await resolveWaiting(candidates[i]); }
+    }));
+
+    const unreadMessages = [];
+    candidates.forEach((thread, i) => {
+      const waiting = resolved[i];
+      if (!waiting) return; // nothing of theirs to show — not a waiting message
+      unreadMessages.push({
+        id: waiting.id,
+        from: waiting.from,
+        to: handle,
+        text: waiting.body,
+        body: waiting.body,
+        createdAt: waiting.created_at,
+        read: false, // If it's in unread threads, it's unread
+        thread_id: thread.id,
+        unread_count: thread.unread,
+      });
+    });
 
     return unreadMessages;
   } catch (e) {

package/version.json

@@ -1,12 +1,11 @@
 {
-  "version": "0.8.23",
-  "updated": "2026-09-01",
-  "changelog": "The install tells the truth about the room. Setup used to say “0 builders online” to every newcomer, because the roster is private before you sign in and it was counting names it was never given; now it reads the count the server actually serves, and after sign-in it lists real people and what they are working on. And a first message to someone before you have signed in no longer asks GitHub to sign you in as them.",
+  "version": "0.8.25",
+  "updated": "2026-09-02",
+  "changelog": "Waiting means their words. After you replied to someone, their next session could open with their own message echoed back as if it had just arrived; now a waiting message is always the other person's newest words. And handles keep their dashes — a GitHub login like synth-stan is looked up as written, so the thread opens instead of coming back empty.",
   "features": [
-    "Setup says how many people are here now — never a zero it did not measure",
-    "After sign-in, setup lists the people actually here and what they are working on",
-    "Messaging @someone before sign-in starts your own sign-in, not one for them",
-    "Setup's quick start is a sentence you can say, not a command to learn"
+    "A waiting message at session start is always the other person's newest message, never your own reply",
+    "Handles with dashes open the right thread",
+    "Long threads read from the end, and the startup check finishes inside its time budget"
   ],
   "deprecated": [],
   "breaking": false,