slashvibe-mcp 0.5.13 → 0.5.15

package/index.js

@@ -252,6 +252,10 @@ const coreTools = {
   // Received collaboration — land the newcomer mid-conversation with a topical match
   vibe_intro: require('./tools/intro'),
 
+  // The Weave — attach this session's strand so Fable can bring moments INTO the
+  // terminal (Spec 1); "Fable holds your half" surfaces via action:'held' + vibe_start.
+  vibe_weave: require('./tools/weave'),
+
   // Return loop — get pinged about DMs you miss while away
   vibe_email: require('./tools/email'),
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "slashvibe-mcp",
-  "version": "0.5.13",
+  "version": "0.5.15",
   "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/tools/start.js

@@ -18,6 +18,7 @@ const notify = require('../notify');
 const patterns = require('../intelligence/patterns');
 const { actions, formatActions } = require('./_actions');
 const { firstDmNudge } = require('./_shared');
+const { weaveMoment } = require('./weave');
 const init = require('./init');
 const { gatherWithTimeout } = require('./_work-context');
 
@@ -350,6 +351,15 @@ async function handler(args) {
     }
   }
 
+  // The Weave — "Fable holds your half": if someone replied to a thread and you
+  // haven't answered, surface the moment so the in-session model can draft your
+  // reply in your voice and send it with one word. Best-effort, never blocks start.
+  try {
+    display += await weaveMoment(myHandle);
+  } catch (e) {
+    // weave is additive magic — a failure here must never break vibe_start
+  }
+
   // Add guest session messages (multiplayer — someone typed into your session)
   if (guestMessages.length > 0) {
     display += `\n\n**🎤 ${guestMessages.length} guest message${guestMessages.length > 1 ? 's' : ''} in your session:**`;

package/tools/weave.js

@@ -0,0 +1,339 @@
+/**
+ * vibe weave — The Weave substrate + "Fable holds your half" (RFC_THE_WEAVE.md).
+ *
+ * This is NOT a new place to go. You never open anything. Once per session your
+ * agent quietly attaches your *strand* — a distilled signal of what you're in the
+ * middle of ({building, stuck_on, last_ship, voice_sample, tags}) — and the magic
+ * is what the loom does back: it emits *moments* into surfaces you already touch
+ * (vibe_start / vibe_who), like carrying your half of a conversation forward when
+ * a reply lands after you've moved on.
+ *
+ * Two things live here:
+ *   Spec 1 — vibe_weave(action:'attach'): spin your strand onto the loom.
+ *   Spec 2 — the "held half": when someone replied to a thread and you haven't
+ *            answered, Fable (your in-session model) drafts your reply in your
+ *            voice and you send it with one word. NEVER auto-sends.
+ *
+ * The draft-then-one-word-confirm pattern is the hard-won vibe_intro lesson:
+ * Fable drafts, the human sends. Consent stays on the human's side.
+ */
+
+const config = require('../config');
+const store = require('../store');
+const { requireInit, normalizeHandle, formatTimeAgo, truncate } = require('./_shared');
+
+const definition = {
+  name: 'vibe_weave',
+  description:
+    "Attach this session's *strand* to the Weave so Fable can bring social moments INTO your terminal (no new place to visit). " +
+    'Call this once, right after vibe_init/vibe_start succeeds. ' +
+    'Spin the strand from what the user is ACTUALLY doing this session, inferred from their files/project/recent work — not a status they typed. ' +
+    'Fields: `building` (one specific line on the current work), `stuck_on` (the wall they keep hitting, if any — an error signature or repeated symptom), `last_ship` (most recent thing that landed), `voice_sample` (2-3 sentences in the user\'s actual writing voice, so Fable can later draft replies that sound like them), `tags` (a few topic keywords). ' +
+    'Everything is a distillation — never send raw source. ' +
+    'Use `action:"held"` to check whether anyone replied to a thread the user left hanging; if so it hands you the context to draft their half. ' +
+    'Use `action:"stuck"` when the user is blocked: it returns builders whose live work or shipped history may be the SAME problem already solved — you judge which candidate is truly the same problem, surface the shape of their fix, and offer a warm intro thread.',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      action: {
+        type: 'string',
+        enum: ['attach', 'held', 'stuck', 'quiet'],
+        description:
+          "'attach' (default): spin/refresh your strand. 'held': surface any conversation where someone replied and you haven't answered, so you can draft the user's half. 'stuck': find builders whose live work or shipped history is the same problem the user is blocked on (pass the wall as `stuck_on`, or it falls back to the attached strand). 'quiet': leave the weave (removes your strand).",
+      },
+      building: {
+        type: 'string',
+        description: 'One specific line on what the user is working on this session (inferred from their real context).',
+      },
+      stuck_on: {
+        type: 'string',
+        description: "The wall the user keeps hitting, if any — an error signature or repeated symptom. Empty if they're cruising.",
+      },
+      last_ship: {
+        type: 'string',
+        description: 'The most recent thing the user shipped/landed this session.',
+      },
+      voice_sample: {
+        type: 'string',
+        description: "2-3 sentences in the user's actual voice, so Fable can later draft messages that sound like them.",
+      },
+      tags: {
+        type: 'array',
+        items: { type: 'string' },
+        description: 'A few topic keywords (e.g. ["oauth","nextjs","postgres"]).',
+      },
+      posture: {
+        type: 'string',
+        enum: ['full', 'receive', 'quiet'],
+        description: "'full' (default): contribute + receive moments. 'receive': receive-only, expose nothing. 'quiet': opt out entirely.",
+      },
+    },
+    required: [],
+  },
+};
+
+function apiBase() {
+  return config.getApiUrl();
+}
+
+// POST the strand digest to the loom. Actor is derived server-side from the
+// token — we send only the distillation.
+async function postStrand({ digest, posture }) {
+  const token = config.getAuthToken();
+  if (!token) return { ok: false, error: 'no_token' };
+  try {
+    const resp = await fetch(`${apiBase()}/api/weave/strand`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        Authorization: `Bearer ${token}`,
+      },
+      body: JSON.stringify({ digest, posture }),
+    });
+    const json = await resp.json().catch(() => ({}));
+    if (!resp.ok) return { ok: false, error: json.error || `http_${resp.status}` };
+    return { ok: true, data: json.data || {} };
+  } catch (e) {
+    return { ok: false, error: e.message };
+  }
+}
+
+// Ask the loom for candidate SOLVERS — builders whose live work or shipped
+// history may be the same problem the user is stuck on. Actor derived server-side
+// from the token; we send only the stuck_on signature (or let the server fall
+// back to the user's own stored strand when we omit it).
+async function postSolve({ stuck_on } = {}) {
+  const token = config.getAuthToken();
+  if (!token) return { ok: false, error: 'no_token' };
+  try {
+    const resp = await fetch(`${apiBase()}/api/weave/solve`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        Authorization: `Bearer ${token}`,
+      },
+      body: JSON.stringify(stuck_on ? { stuck_on } : {}),
+    });
+    const json = await resp.json().catch(() => ({}));
+    if (!resp.ok) return { ok: false, error: json.error || `http_${resp.status}` };
+    return { ok: true, data: json.data || {} };
+  } catch (e) {
+    return { ok: false, error: e.message };
+  }
+}
+
+/**
+ * Find conversations where the other person replied and the user hasn't answered
+ * yet — the "you moved on, a reply landed" signal. Uses unread count as the
+ * proxy (they messaged, you haven't opened/replied). Returns the freshest one
+ * with the actual inbound text pulled from the thread, or null.
+ *
+ * Exported so vibe_start can surface the moment inline without re-implementing it.
+ */
+async function findHeldHalf(myHandle) {
+  let inbox = [];
+  try {
+    inbox = (await store.getInbox(myHandle)) || [];
+  } catch {
+    return null;
+  }
+  // Threads with something waiting for your half, freshest first.
+  const waiting = inbox
+    .filter((t) => t && t.handle && (t.unread || 0) > 0)
+    .sort((a, b) => (b.lastTimestamp || 0) - (a.lastTimestamp || 0));
+  if (waiting.length === 0) return null;
+
+  const top = waiting[0];
+  const them = normalizeHandle(top.handle);
+
+  // Pull the thread to get the actual inbound message + a little context.
+  let inboundBody = top.lastMessage || '';
+  let inboundAt = top.lastTimestamp || null;
+  let myLast = '';
+  try {
+    const thread = await store.getThread(myHandle, them);
+    if (Array.isArray(thread) && thread.length) {
+      const lastReceived = [...thread].reverse().find((m) => m.direction === 'received');
+      if (lastReceived) {
+        inboundBody = lastReceived.body || inboundBody;
+        inboundAt = lastReceived.timestamp || inboundAt;
+      }
+      const lastSent = [...thread].reverse().find((m) => m.direction === 'sent');
+      if (lastSent) myLast = lastSent.body || '';
+    }
+  } catch {
+    // best-effort — the inbox preview is enough to surface the moment
+  }
+
+  if (!inboundBody) return null;
+  return {
+    handle: them,
+    inbound: inboundBody,
+    inboundAgo: inboundAt ? formatTimeAgo(inboundAt) : 'recently',
+    myLast,
+    otherWaiting: waiting.length - 1,
+  };
+}
+
+/**
+ * Render the held-half moment as a markdown block for vibe_start, or '' when
+ * there's nothing to hold. This is the wedge: the model reading this block IS
+ * Fable — it drafts the user's reply in their voice and offers one-word send.
+ */
+async function weaveMoment(myHandle) {
+  const held = await findHeldHalf(myHandle);
+  if (!held) return '';
+  const inbound = truncate(held.inbound, 240);
+  let block =
+    `\n\n🧵 **@${held.handle} replied and you haven't answered (${held.inboundAgo}):**` +
+    `\n> ${inbound}` +
+    `\n\n_Fable can hold your half here — draft the reply in your voice from what you were building, ` +
+    `show it, and send it with one word. Draft it now, then: **send it (y) · edit · let it sit**. ` +
+    `On yes, deliver with \`vibe_dm @${held.handle}\`._`;
+  if (held.otherWaiting > 0) {
+    block += `\n_(+${held.otherWaiting} more thread${held.otherWaiting > 1 ? 's' : ''} waiting on you.)_`;
+  }
+  return block;
+}
+
+async function handler(args = {}) {
+  const initCheck = requireInit();
+  if (initCheck) return initCheck;
+
+  const myHandle = config.getHandle();
+  const action = args.action || 'attach';
+
+  // ── Held-half: surface a conversation waiting on the user's reply ─────────
+  if (action === 'held') {
+    const held = await findHeldHalf(myHandle);
+    if (!held) {
+      return {
+        display:
+          "Nothing waiting on your half right now — every thread's answered. " +
+          '`vibe who` to see who else is around.',
+      };
+    }
+    return {
+      display:
+        `🧵 **@${held.handle} replied ${held.inboundAgo} — you haven't answered:**\n` +
+        `> ${truncate(held.inbound, 280)}\n\n` +
+        `Draft @${myHandle}'s reply in their voice from what they were building, show it, then ask: ` +
+        `**send it (y) · edit · let it sit**. On yes, send with \`vibe_dm @${held.handle}\`.`,
+      _heldHalf: held,
+    };
+  }
+
+  // ── Stuck: find a solver whose work is the same problem, already solved ────
+  if (action === 'stuck') {
+    const result = await postSolve({ stuck_on: args.stuck_on || '' });
+    if (!result.ok) {
+      if (result.error === 'no_token' || result.error === 'unauthenticated') {
+        return {
+          display:
+            "⚠️ Couldn't reach the loom — your /vibe session isn't authenticated. Run `vibe init` first.",
+        };
+      }
+      return {
+        display: `⚠️ Couldn't search the weave for solvers (${result.error}). Best-effort — try again.`,
+      };
+    }
+
+    const data = result.data || {};
+    const candidates = Array.isArray(data.candidates) ? data.candidates : [];
+    if (!data.stuck_on) {
+      return {
+        display:
+          "No stuck-signal to match on. Pass what the user is fighting as `stuck_on`, " +
+          'or attach a strand with a `stuck_on` first (`vibe_weave` with the wall they keep hitting).',
+      };
+    }
+    if (candidates.length === 0) {
+      return {
+        display:
+          `Searched the weave against _"${truncate(data.stuck_on, 120)}"_ — ` +
+          `no builder's live work or shipped history looks like the same problem yet. ` +
+          `Nothing to surface; don't invent a match.`,
+      };
+    }
+
+    // Hand the raw recall pool to the model. The model IS Fable here: it decides
+    // which candidate (if any) is TRULY the same problem, describes the shape of
+    // the fix from their work, and offers a warm intro thread — never fabricates.
+    const lines = candidates.slice(0, 8).map((c) => {
+      const where = c.online ? 'live now' : 'shipped';
+      const matched = Array.isArray(c.matched) && c.matched.length
+        ? ` · overlaps: ${c.matched.slice(0, 5).join(', ')}`
+        : '';
+      return `• @${c.handle} (${where}${matched}): ${truncate(c.text || '', 200)}`;
+    });
+
+    return {
+      display:
+        `🧵 **The user is stuck on:** _"${truncate(data.stuck_on, 160)}"_\n\n` +
+        `Candidate solvers from the weave (${candidates.length} found · ${data.live || 0} live):\n` +
+        lines.join('\n') +
+        `\n\n**Your job (you are Fable at read time):** judge which candidate — if any — is ` +
+        `truly the *same problem*, not just shared keywords. Two different error messages can be ` +
+        `the same root cause; only you can see that. If one genuinely matches:\n` +
+        `  1. Name the shape of what worked for them (from their text above), so the user gets ` +
+        `unstuck even without talking.\n` +
+        `  2. Offer a warm thread: "@${'{handle}'} hit this and shipped a fix — want me to open a ` +
+        `thread so you can ask? (y)". On yes, send with \`vibe_dm @{handle}\` in the user's voice.\n` +
+        `If NONE is truly the same problem, say so plainly — never fabricate a match or a fix.`,
+      _solvers: candidates,
+    };
+  }
+
+  // ── Quiet: leave the weave ────────────────────────────────────────────────
+  if (action === 'quiet' || args.posture === 'quiet') {
+    await postStrand({ digest: {}, posture: 'quiet' });
+    return {
+      display: '🔕 Left the weave. Your strand is gone — no strand contributed, no moments received. Weave again anytime.',
+    };
+  }
+
+  // ── Attach (default): spin the strand onto the loom ───────────────────────
+  const posture = ['full', 'receive'].includes(args.posture) ? args.posture : 'full';
+  const digest = {
+    building: args.building || '',
+    stuck_on: args.stuck_on || '',
+    last_ship: args.last_ship || '',
+    voice_sample: args.voice_sample || '',
+    tags: Array.isArray(args.tags) ? args.tags : [],
+  };
+
+  const result = await postStrand({ digest, posture });
+  if (!result.ok) {
+    if (result.error === 'no_token' || result.error === 'unauthenticated') {
+      return {
+        display:
+          "⚠️ Couldn't attach your strand — your /vibe session isn't authenticated. Run `vibe init` first, then weave.",
+      };
+    }
+    return {
+      display: `⚠️ Couldn't attach your strand (${result.error}). It's best-effort — try again next session.`,
+    };
+  }
+
+  const live = result.data.live || 0;
+  const liveLine =
+    live > 0
+      ? `${live} other builder${live > 1 ? 's' : ''} live · Fable is watching for moments`
+      : "you're the first strand live · Fable will weave you in as others arrive";
+
+  if (posture === 'receive') {
+    return {
+      display:
+        `✓ Woven in **receive-only** — you'll get moments, but your strand stays private.\n` +
+        `  (${liveLine})`,
+    };
+  }
+  return {
+    display:
+      `✓ **strand attached to the weave** — nothing to visit; the magic comes to you.\n` +
+      `  (${liveLine})\n\n` +
+      `_When a reply lands after you've moved on, Fable will hold your half and offer it back here._`,
+  };
+}
+
+module.exports = { definition, handler, weaveMoment, findHeldHalf };

package/version.json

@@ -1,8 +1,11 @@
 {
-  "version": "0.5.13",
+  "version": "0.5.15",
   "updated": "2026-07-04",
-  "changelog": "New: you arrive already in a conversation. Right after you sign in, /vibe looks at what you're building this session, finds a real person online working on something related, and drafts a warm two-sided intro — you send it with one word. No more `vibe who` then cold-DMing a stranger; you land mid-conversation with someone who gets what you're doing.",
+  "changelog": "The Weave gets its most useful moment: when you're stuck, Fable finds the builder whose live work or shipped history is the SAME problem — already solved — and hands you the shape of the fix, not just an introduction. Two different error messages can be the same root cause; only Fable can see that. Ask with `vibe_weave stuck`, or let it surface when you keep circling the same wall.",
   "features": [
+    "Stuck-signatures (vibe_weave stuck) — blocked on something? Fable searches the weave for whoever already solved your exact problem — matching by the wall you're hitting, not keywords — surfaces the shape of their fix so you get unstuck, and offers to open a warm thread so you can ask. Never invents a match",
+    "The Weave (vibe_weave) — attach this session's strand (what you're building, what you're stuck on, your voice) so /vibe can bring social moments INTO your terminal. Nothing to visit; the magic comes to you. Weave in full, receive-only, or quiet — opting out is first-class",
+    "Fable holds your half — when someone replies to a thread you haven't answered, vibe start surfaces it and drafts your reply in your voice from what you were building. Send it with one word. Never auto-sends",
     "Received collaboration (vibe_intro) — after sign-in, your agent summarizes what you're building and /vibe matches you to a real human online whose current work or recent ship overlaps, then drafts a two-sided opener you send with one word. The signal only /vibe can see — what's inside two people's live coding sessions at once — becomes the introduction",
     "Bulletproof first-run — `let's vibe` narrates the browser sign-in, gives you a clickable fallback login link, and every timeout/error path tells you the correct retry. You can't get stranded",
     "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",