slashvibe-mcp 0.5.9 → 0.5.11

package/index.js

@@ -256,7 +256,9 @@ const coreTools = {
   vibe_ship: require('./tools/ship'),
   vibe_feed: require('./tools/feed'),
 
-  // Play — the original January magic: shared experiences over the DM transport
+  // Play — the original January magic: shared experiences over the DM transport.
+  // vibe_play is the open primitive; game/poem/corpse are hardcoded on-ramps.
+  vibe_play: require('./tools/play'),
   vibe_game: require('./tools/game'),
   vibe_poem: require('./tools/poem'),
   vibe_corpse: require('./tools/corpse'),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "slashvibe-mcp",
-  "version": "0.5.9",
+  "version": "0.5.11",
   "mcpName": "io.github.vibecodinginc/vibe",
   "description": "Social layer for Claude Code - DMs, presence, Matrix multiplayer rooms, and connection between AI-assisted developers",
   "main": "index.js",

package/store/api.js

@@ -352,7 +352,9 @@ async function getActiveUsers() {
       awayAt: u.awayAt || u.context?.awayAt || null,
       // v2 additions
       isLive: u.isLive || false,
-      isAgent: u.isAgent || false
+      isAgent: u.isAgent || false,
+      // Presence texture (server-enriched): most-recent ship
+      lastShip: u.lastShip || null
     }));
 
     // Sync presence data to local profiles (non-blocking)

package/tools/_shared.js

@@ -202,6 +202,88 @@ async function fetchRelevantUsers(handle, context = 'dm_suggest', limit = 5) {
   }
 }
 
+// ─────────────────────────────────────────────────────────────
+// First-DM activation (dormant users)
+// ─────────────────────────────────────────────────────────────
+
+/**
+ * Has this user ever sent a DM?
+ * Durable signal: a persisted `firstDmSent` flag (set on first successful send
+ * via markFirstDmSent), seeded by the presence of any conversation memory —
+ * existing messagers almost always have memory threads, so they're pre-excluded
+ * and never see the nudge. Self-heals: the moment they send one DM, the flag
+ * flips and the nudge is gone for good.
+ *
+ * @param {Array} threads - result of memory.listThreads()
+ * @returns {boolean}
+ */
+function hasEverMessaged(threads) {
+  try {
+    const cfg = config.load();
+    if (cfg && cfg.firstDmSent) return true;
+  } catch (e) {}
+  return Array.isArray(threads) && threads.length > 0;
+}
+
+/**
+ * Persist the "has sent a first DM" flag so the activation nudge stops.
+ * Called from dm.js on a successful send. Cheap, idempotent, best-effort.
+ */
+function markFirstDmSent() {
+  try {
+    const cfg = config.load();
+    if (!cfg || !cfg.firstDmSent) config.save({ firstDmSent: true });
+  } catch (e) {}
+}
+
+/**
+ * Pick the most-recently-active real human from a presence list, with a
+ * ready-to-paste opener. Filters out agents (is_agent) and self. Warms the
+ * opener from the target's most recent ship (lastShip) when available.
+ *
+ * @param {Array} others - active users (already excludes self by convention)
+ * @returns {{handle: string, opener: string}|null}
+ */
+function pickDormantTarget(others) {
+  const humans = (others || []).filter((u) => u && u.handle && !u.is_agent);
+  if (humans.length === 0) return null;
+  humans.sort(
+    (a, b) => new Date(b.lastSeen || b.last_seen || 0) - new Date(a.lastSeen || a.last_seen || 0)
+  );
+  const pick = humans[0];
+  // The opener is pasted inside a double-quoted `vibe dm @x "..."` command, so
+  // strip any double quotes/backslashes the ship text itself contains (ship
+  // content is arbitrary) and single-quote the snippet — otherwise an embedded
+  // quote closes the command early and breaks the paste.
+  const rawShip = pick.lastShip && pick.lastShip.what;
+  const shipped = rawShip ? String(rawShip).replace(/["\\]/g, '').trim().slice(0, 48) : '';
+  const opener = shipped
+    ? `hey! saw you shipped '${shipped}' — what are you building?`
+    : `hey! what are you building?`;
+  return { handle: pick.handle, opener };
+}
+
+/**
+ * Render the first-DM activation nudge, or '' when it shouldn't show.
+ * Shows only for users who have never sent a DM, and only when a real human is
+ * around right now to receive it. This is the returning-user twin of the
+ * new-user welcome first-message pull — it reaches the dormant existing users
+ * where the actual funnel is.
+ *
+ * @param {Array} others - active users (excludes self)
+ * @param {Array} threads - memory.listThreads()
+ * @returns {string} markdown block (leading blank line) or ''
+ */
+function firstDmNudge(others, threads) {
+  if (hasEverMessaged(threads)) return '';
+  const target = pickDormantTarget(others);
+  if (!target) return '';
+  return (
+    `\n\n**👋 You haven't messaged anyone yet — @${target.handle} is around right now:**` +
+    `\n   vibe dm @${target.handle} "${target.opener}"`
+  );
+}
+
 // ─────────────────────────────────────────────────────────────
 // Exports
 // ─────────────────────────────────────────────────────────────
@@ -230,5 +312,11 @@ module.exports = {
   error,
 
   // API
-  fetchRelevantUsers
+  fetchRelevantUsers,
+
+  // First-DM activation (dormant users)
+  hasEverMessaged,
+  markFirstDmSent,
+  pickDormantTarget,
+  firstDmNudge
 };

package/tools/dm.js

@@ -8,7 +8,7 @@ const memory = require('../memory');
 const userProfiles = require('../store/profiles');
 const patterns = require('../intelligence/patterns');
 const { trackMessage, checkBurst } = require('./summarize');
-const { requireInit, normalizeHandle, truncate, warning, fetchRelevantUsers } = require('./_shared');
+const { requireInit, normalizeHandle, truncate, warning, fetchRelevantUsers, markFirstDmSent } = require('./_shared');
 const { actions, formatActions } = require('./_actions');
 
 const definition = {
@@ -110,6 +110,10 @@ async function handler(args) {
     };
   }
 
+  // Mark that this user has sent a DM — silences the first-DM activation nudge
+  // (vibe start / vibe who) for good. Durable, idempotent, best-effort.
+  markFirstDmSent();
+
   // Log social pattern (quietly, in background)
   patterns.logMessageSent(them);
 

package/tools/play.js

@@ -0,0 +1,208 @@
+/**
+ * vibe play — the open channel for emergent, AI-improvised social play
+ *
+ * game / poem / corpse each hardcode one activity's rules. This tool hardcodes
+ * NONE. It is the bare primitive underneath all of them: carry an arbitrary
+ * `state` object back and forth over the DM thread, with a freeform `note`, and
+ * let the two Claude sessions invent whatever they want on top of it — chess,
+ * 20 questions, a co-written story, a shared drawing, a debate, a game neither
+ * player has a name for yet.
+ *
+ * The rules live in the conversation, not in this file. That's the whole point:
+ * the platform supplies the presence + the channel; the creativity is emergent
+ * from the humans and their Claudes. game/poem/corpse are now just friendly
+ * on-ramps that teach the pattern; `vibe play` is the pattern itself.
+ *
+ * Transport is identical to the others: `payload: { type:'play', ... }` on a DM,
+ * durable via the Postgres payload column, read back with store.getThread().
+ */
+
+const config = require('../config');
+const store = require('../store');
+const { requireInit, normalizeHandle } = require('./_shared');
+
+// Guardrail so a runaway state blob can't wedge the DM store. Generous — a
+// chess board, a long story-so-far, or a 100-cell canvas all fit easily.
+const MAX_STATE_BYTES = 24000;
+
+/**
+ * Find the most recent play session in a DM thread.
+ */
+function getPlaySession(thread) {
+  for (let i = thread.length - 1; i >= 0; i--) {
+    const p = thread[i].payload;
+    if (p && p.type === 'play') return p;
+  }
+  return null;
+}
+
+/**
+ * Accept state as a structured object/array/primitive, or a JSON string, or a
+ * plain string. We never force a shape — whatever the two Claudes agree on.
+ */
+function coerceState(raw) {
+  if (raw === undefined || raw === null) return undefined;
+  if (typeof raw === 'string') {
+    const s = raw.trim();
+    if (!s) return undefined;
+    try {
+      return JSON.parse(s);
+    } catch {
+      return s; // not JSON — keep the raw string, it's a valid state too
+    }
+  }
+  return raw;
+}
+
+function stateBytes(state) {
+  if (state === undefined) return 0;
+  try {
+    return Buffer.byteLength(typeof state === 'string' ? state : JSON.stringify(state), 'utf8');
+  } catch {
+    return Infinity;
+  }
+}
+
+/**
+ * Render whatever state is, legibly, for the local Claude to reason about.
+ */
+function renderState(state) {
+  if (state === undefined) return '_(no state yet — you define it)_';
+  if (typeof state === 'string') return '```\n' + state + '\n```';
+  try {
+    return '```json\n' + JSON.stringify(state, null, 2) + '\n```';
+  } catch {
+    return '_(unrenderable state)_';
+  }
+}
+
+const definition = {
+  name: 'vibe_play',
+  description:
+    'The open channel for playing ANY shared activity with another viber — you and their Claude improvise the rules, this tool just carries the state. No built-in game logic. Use it for anything two sessions can invent: chess, 20 questions, a co-written story, battleship, a shared ascii drawing, a debate, a made-up game. ' +
+    'Pass a freeform `state` (any JSON — the current board/story/whatever) and a `note` (a plain-language message to the other player and their Claude). ' +
+    'Call it with no state to READ the current session so you can interpret it and take your turn. This is the primitive under vibe_game / vibe_poem / vibe_corpse — reach for it when the activity is anything else.',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      handle: {
+        type: 'string',
+        description: 'Who to play with (e.g., @solienne)',
+      },
+      note: {
+        type: 'string',
+        description:
+          "A plain-language message to the other player and their Claude — what you did, whose turn it is, the rules if you're starting. This is what shows in their DM.",
+      },
+      state: {
+        description:
+          'The current activity state, as any JSON value (object, array, or string). Whatever shape you and the other Claude agree on — a board, a story-so-far, a score, moves. Omit to just read the current state.',
+      },
+      kind: {
+        type: 'string',
+        description:
+          "A freeform label for the activity, e.g. 'chess', '20-questions', 'story', 'battleship'. You coin it — it's just a hint so both sides know what game this is.",
+      },
+      done: {
+        type: 'boolean',
+        description: 'Mark the activity finished after this turn.',
+      },
+    },
+    required: ['handle'],
+  },
+};
+
+async function handler(args) {
+  const initCheck = requireInit();
+  if (initCheck) return initCheck;
+
+  const me = config.getHandle();
+  const them = normalizeHandle(args.handle);
+
+  if (them === me) {
+    return { display: "You can't play with yourself here — invite someone: `vibe play @handle`." };
+  }
+
+  const thread = await store.getThread(me, them);
+  const last = getPlaySession(thread);
+
+  const incomingState = coerceState(args.state);
+  const note = args.note ? String(args.note).trim() : '';
+  const kind = (args.kind ? String(args.kind).trim() : '') || (last && last.kind) || null;
+  const done = args.done === true;
+
+  const hasWrite = incomingState !== undefined || note || done;
+
+  // ── READ: no write args → surface the current session for this Claude to act on.
+  if (!hasWrite) {
+    if (!last) {
+      return {
+        display:
+          `## play with @${them}\n\n` +
+          `_No shared activity going yet._\n\n` +
+          `Start anything — you and @${them}'s Claude make up the rules. Examples:\n` +
+          `\`vibe play @${them} --kind "chess" --note "you're white, your move" --state '{"board":"start"}'\`\n` +
+          `\`vibe play @${them} --kind "20-questions" --note "I'm thinking of something. ask away."\`\n` +
+          `\`vibe play @${them} --kind "story" --note "once upon a time..." --state "once upon a time"\`\n\n` +
+          `(For the classics there are shortcuts: \`vibe game\`, \`vibe poem\`, \`vibe corpse\`.)`,
+      };
+    }
+
+    const who = last.by === me ? 'you' : `@${last.by}`;
+    let display = `## play with @${them}${last.kind ? ` — ${last.kind}` : ''}\n\n`;
+    if (last.note) display += `last from ${who}: "${last.note}"\n\n`;
+    display += `state:\n${renderState(last.state)}\n`;
+    if (last.done) {
+      display += `\n✨ This one's finished. Start another with \`vibe play @${them} …\``;
+    } else if (last.by === me) {
+      display += `\n_Waiting on @${them} — they play next._`;
+    } else {
+      display +=
+        `\n**Your move.** Interpret the state above, decide what happens next, and send it back:\n` +
+        `\`vibe play @${them}${last.kind ? ` --kind "${last.kind}"` : ''} --note "…" --state '{…}'\`  (add \`--done\` to finish)`;
+    }
+    return { display };
+  }
+
+  // ── WRITE: take a turn.
+  // Carry the previous state forward if the caller didn't supply a new one.
+  const newState = incomingState !== undefined ? incomingState : last ? last.state : undefined;
+
+  if (stateBytes(newState) > MAX_STATE_BYTES) {
+    return {
+      display: `That state is too big (>${Math.round(MAX_STATE_BYTES / 1000)}KB). Keep the shared state compact — summarize instead of accumulating raw history.`,
+    };
+  }
+
+  const payload = {
+    type: 'play',
+    kind: kind || null,
+    state: newState,
+    note: note || null,
+    by: me,
+    done,
+  };
+
+  // The DM body is what lands in their inbox. Lead with the note; add a light
+  // hint so their Claude knows to open the session and respond.
+  let body;
+  if (done) {
+    body = note ? `${note}\n\n(sealed our ${kind || 'game'} 🎲)` : `Sealed our ${kind || 'game'} 🎲`;
+  } else {
+    body = note || `Your move 🎲`;
+    body += `\n\n▸ open with \`vibe play @${me}\` to see the state and reply`;
+  }
+
+  await store.sendMessage(me, them, body, 'dm', payload);
+
+  let display = `## play with @${them}${kind ? ` — ${kind}` : ''}\n\n`;
+  display += `state:\n${renderState(newState)}\n`;
+  if (done) {
+    display += `\n✨ Sealed and sent to @${them}. Start another anytime.`;
+  } else {
+    display += `\nSent to @${them}. Waiting for their move…`;
+  }
+  return { display };
+}
+
+module.exports = { definition, handler };

package/tools/start.js

@@ -17,6 +17,7 @@ const memory = require('../memory');
 const notify = require('../notify');
 const patterns = require('../intelligence/patterns');
 const { actions, formatActions } = require('./_actions');
+const { firstDmNudge } = require('./_shared');
 const init = require('./init');
 const { gatherWithTimeout } = require('./_work-context');
 
@@ -330,6 +331,11 @@ async function handler(args) {
     }
   }
 
+  // First-DM activation nudge (dormant users only): if this user has never sent
+  // a DM, point them at a real human who's around right now with a ready opener.
+  // Gated inside firstDmNudge so we never nag people who already message.
+  display += firstDmNudge(others, threads);
+
   // Add unread messages section (if any)
   if (unreadCount > 0) {
     const unreadSenders = inboxThreads.filter(t => t.unread > 0);

package/tools/who.js

@@ -10,7 +10,8 @@
 const config = require('../config');
 const store = require('../store');
 const notify = require('../notify');
-const { formatTimeAgo, requireInit } = require('./_shared');
+const { formatTimeAgo, requireInit, firstDmNudge } = require('./_shared');
+const memory = require('../memory');
 const { actions, formatActions } = require('./_actions');
 const { enhanceUsersWithInference } = require('../intelligence/infer');
 const { getTopSerendipity, getAllSerendipity } = require('../intelligence/serendipity');
@@ -225,10 +226,25 @@ _Check back in a bit — builders come and go._`
         display += `   ${operatorTag}\n`;
       }
       display += `   ${activity}\n`;
+      // Presence texture: what they last shipped
+      if (u.lastShip && u.lastShip.what) {
+        display += `   _last shipped: "${u.lastShip.what}" ${u.lastShip.ago}_\n`;
+      }
       display += `   _${timeAgo}_\n\n`;
     });
   }
 
+  // First-DM activation nudge (dormant users only): if signed in and this user
+  // has never sent a DM, point them at a real human who's active right now.
+  // firstDmNudge self-gates so people who already message never see it.
+  if (isInit) {
+    let threads = [];
+    try { threads = memory.listThreads(); } catch (e) {}
+    const activeOthers = active.filter(u => u.handle !== myHandle);
+    const nudge = firstDmNudge(activeOthers, threads);
+    if (nudge) display += nudge.replace(/^\n+/, '') + `\n\n`;
+  }
+
   // Away section (expanded with messages if present)
   if (away.length > 0) {
     display += `---\n\n`;

package/version.json

@@ -1,11 +1,13 @@
 {
-  "version": "0.5.9",
+  "version": "0.5.11",
   "updated": "2026-07-03",
-  "changelog": "New way to play together: the exquisite corpse. `vibe_corpse @handle` starts a surrealist story you build one line at a time — but you only ever see the LAST line, never the whole thing, until someone seals it and the full corpse is revealed. Joins `vibe_game` (tic-tac-toe) and `vibe_poem` (emoji poem) as shared experiences carried over your DM thread. Ship together, play together.",
+  "changelog": "Never messaged anyone yet? `vibe start` and `vibe who` now nudge you toward a real human who's around right now — a one-tap, ready-to-paste `vibe dm` with an opener warmed by what they just shipped. It shows only until you send your first DM, then it's gone for good. The whole point of the green dot is that someone's actually there; this closes the gap between seeing that and saying hi.",
   "features": [
-    "vibe_corpse — write an exquisite corpse with another viber: alternate lines blind to all but the last, then seal for the big reveal",
-    "vibe_game — play tic-tac-toe with another viber, move by move, carried over your DM thread",
-    "vibe_poem — build a collaborative emoji poem together, one line each, until someone seals it"
+    "First-DM nudge — if you've never messaged anyone, vibe start/who surface the most-recently-active real human as a one-tap opener, warmed by their latest ship. Self-heals: disappears the moment you send your first DM",
+    "vibe_play — the open primitive: pass any JSON state + a note to another viber, read it back to take your turn, and improvise any activity two sessions can dream up",
+    "vibe_corpse — write an exquisite corpse: alternate lines blind to all but the last, then seal for the big reveal",
+    "vibe_game — play tic-tac-toe with another viber, move by move, over your DM thread",
+    "vibe_poem — build a collaborative emoji poem together, one line each"
   ],
   "deprecated": [
     "vibe_pair — use Matrix room invites",