slashvibe-mcp 0.5.12 → 0.5.14

package/index.js

@@ -249,6 +249,13 @@ const coreTools = {
   vibe_inbox: require('./tools/inbox'),
   vibe_reply: require('./tools/reply'),
 
+  // 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.12",
+  "version": "0.5.14",
   "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/_shared.js

@@ -284,6 +284,120 @@ function firstDmNudge(others, threads) {
   );
 }
 
+// ─────────────────────────────────────────────────────────────
+// Received collaboration (topical intro on onboarding)
+// ─────────────────────────────────────────────────────────────
+
+// Words too generic to signal a shared topic. Kept aligned with the
+// server-side building-keyword filter in api/lib/relevancy.js.
+const INTRO_STOPWORDS = new Set([
+  'the', 'and', 'for', 'with', 'that', 'this', 'from', 'will', 'app', 'apps',
+  'using', 'your', 'you', 'building', 'build', 'built', 'working', 'work',
+  'make', 'making', 'some', 'into', 'just', 'like', 'want', 'need', 'trying',
+  'have', 'has', 'been', 'about', 'their', 'they', 'what', 'when', 'code',
+  'coding', 'stuff', 'thing', 'things', 'project', 'projects', 'feature',
+  'features', 'new', 'around', 'currently', 'right', 'now', 'today', 'session',
+]);
+
+/**
+ * Extract meaningful, de-duped keywords from free text for topic matching.
+ * Mirrors the >3-char + common-word filter used server-side so client and
+ * server agree on what "related" means.
+ */
+function introKeywords(text) {
+  return [
+    ...new Set(
+      String(text || '')
+        .toLowerCase()
+        .replace(/[^a-z0-9\s+#.-]/g, ' ')
+        .split(/\s+/)
+        .filter((w) => w.length > 3 && !INTRO_STOPWORDS.has(w))
+    ),
+  ];
+}
+
+// The topical text we know about an online human: what they're working on
+// right now + their most recent ship. Both are already public (presence + board).
+function introTopicText(u) {
+  const ship = u && u.lastShip && u.lastShip.what ? u.lastShip.what : '';
+  return `${(u && u.one_liner) || ''} ${ship}`.trim();
+}
+
+// Strip quotes/backslashes and clamp — the opener is pasted inside a
+// double-quoted `vibe dm @x "..."` command, so an embedded quote would close
+// it early. Same paste-safety rule as pickDormantTarget.
+function sanitizeSnippet(text, max = 48) {
+  return String(text || '')
+    .replace(/["\\]/g, '')
+    .replace(/\s+/g, ' ')
+    .trim()
+    .slice(0, max);
+}
+
+/**
+ * Compose a two-sided warm opener: references what the newcomer is building AND
+ * what the target is on, anchored to the topic they share. This is the whole
+ * point of "received collaboration" — the newcomer arrives already in a
+ * relevant conversation instead of cold-DMing a stranger.
+ */
+function composeIntro(building, target, shared) {
+  const mine = sanitizeSnippet(building, 60);
+  // For DISPLAY use one clean phrase — what they're doing now, else their last
+  // ship. (introTopicText concatenates both for MATCHING, which reads badly.)
+  const theirRaw =
+    (target && target.one_liner) ||
+    (target && target.lastShip && target.lastShip.what) ||
+    '';
+  const theirWork = sanitizeSnippet(theirRaw, 48);
+  const topic = shared && shared[0];
+  if (theirWork && topic) {
+    return `hey! i just jumped into /vibe — i'm working on ${mine} and saw you're on ${theirWork}. we're both deep in ${topic}, want to compare notes?`;
+  }
+  if (theirWork) {
+    return `hey! i just jumped into /vibe — i'm working on ${mine} and saw you're on ${theirWork}. what are you building?`;
+  }
+  return `hey! i just jumped into /vibe — i'm working on ${mine}. what are you building?`;
+}
+
+/**
+ * Pick the online human whose current work / recent ship most overlaps with what
+ * the newcomer is building this session. Returns a topically-matched target with
+ * a composed two-sided opener, or null when nothing lines up (caller should fall
+ * back to pickDormantTarget's recency pick). Agents are already excluded upstream
+ * (getActiveUsers only returns active+away, never the agents lane) but we guard
+ * anyway.
+ *
+ * @param {Array} others - active users (caller excludes self)
+ * @param {string} building - the agent's one-line summary of the user's current work
+ * @returns {{handle, opener, shared, related}|null}
+ */
+function pickRelatedTarget(others, building) {
+  const myWords = introKeywords(building);
+  if (myWords.length === 0) return null;
+  const humans = (others || []).filter((u) => u && u.handle && !u.isAgent && !u.is_agent);
+  let best = null;
+  for (const u of humans) {
+    const theirWords = introKeywords(introTopicText(u));
+    const shared = myWords.filter((w) => theirWords.includes(w));
+    if (shared.length === 0) continue;
+    const recency = new Date(u.lastSeen || u.last_seen || 0).getTime() || 0;
+    if (
+      !best ||
+      shared.length > best.score ||
+      (shared.length === best.score && recency > best.recency)
+    ) {
+      best = { user: u, score: shared.length, shared, recency };
+    }
+  }
+  if (!best) return null;
+  return {
+    handle: best.user.handle,
+    shared: best.shared,
+    opener: composeIntro(building, best.user, best.shared),
+    related: true,
+  };
+}
+
 // ─────────────────────────────────────────────────────────────
 // Exports
 // ─────────────────────────────────────────────────────────────
@@ -318,5 +432,10 @@ module.exports = {
   hasEverMessaged,
   markFirstDmSent,
   pickDormantTarget,
-  firstDmNudge
+  firstDmNudge,
+
+  // Received collaboration (topical intro on onboarding)
+  introKeywords,
+  composeIntro,
+  pickRelatedTarget
 };

package/tools/init.js

@@ -785,10 +785,18 @@ To check messages: \`vibe inbox\`${emailNudge}`
       const whoNudge = presence.humans > 1
         ? `**"vibe who"** — see the ${presence.humans} builders online right now`
         : `**"vibe who"** — see who's building right now`;
-      const nextSteps = `\n\n---\n**Your first 60 seconds**\n`
-        + `1. ${whoNudge}\n`
-        + `2. **"vibe @someone hey"** — your first DM lands right in their terminal\n`
-        + `3. **"vibe ship <what you're building>"** — put yourself on the board\n\n`
+      // Received collaboration: instead of handing the newcomer a cold to-do
+      // list ("go DM a stranger"), have their agent introduce them to someone
+      // online working on something related — they land mid-conversation. The
+      // directive below tells the model to call vibe_intro with what this user
+      // is building THIS session (context only /vibe can see). vibe_intro
+      // handles the empty-room / no-match cases gracefully, so it's always safe
+      // to attempt. Draft-first: it proposes, the user says yes, then send.
+      const nextSteps = `\n\n---\n**You're in — let's land you in a real conversation, not an empty inbox.**\n`
+        + `\n→ _Agent: in one line, summarize what this user is building in the current session_`
+        + ` _(infer it from their open files, project, and recent work), then call the_ **\`vibe_intro\`** _tool with that as \`building\`._`
+        + ` _It finds someone online working on something related and drafts a warm intro. Show them the match, and if they're up for it, call \`vibe_intro\` again with \`send: true\`._\n`
+        + `\nPrefer to look around first? ${whoNudge}, or **"vibe ship <what you're building>"** to put yourself on the board.\n\n`
         + `_Stuck? Say **"vibe help"**._`;
 
       // One-time email nudge — only for users we can't otherwise reach (no

package/tools/intro.js

@@ -0,0 +1,151 @@
+/**
+ * vibe intro — Received collaboration.
+ *
+ * The newcomer's agent knows what they're building this session (context only
+ * /vibe can see). This tool takes that one-line summary, finds a real human
+ * online whose current work / recent ship overlaps, and DRAFTS a two-sided warm
+ * intro so the newcomer arrives already in a relevant conversation instead of
+ * cold-DMing a stranger.
+ *
+ * Default is draft-only: the tool composes who + what-to-say (the hard part) and
+ * the user sends with one word. Pass send:true to actually deliver after they
+ * assent — the send routes through the normal authenticated vibe_dm path.
+ */
+
+const config = require('../config');
+const store = require('../store');
+const {
+  requireInit,
+  normalizeHandle,
+  pickRelatedTarget,
+  pickDormantTarget,
+} = require('./_shared');
+
+const definition = {
+  name: 'vibe_intro',
+  description:
+    "Introduce this user to a real human online who's building something related, so they land mid-conversation instead of staring at an empty inbox. " +
+    'Call this right after vibe_init succeeds (and any time a returning user hasn\'t connected yet). ' +
+    'Pass `building`: a short, specific, first-person-free summary of what the user is actually working on in THIS session — infer it from the current files, project, and recent work (e.g. "an OAuth PKCE login flow in a Next.js app", "a Postgres migration for a chat schema", "a Tauri menubar app"). ' +
+    'The tool finds the best-matched online human and drafts a warm two-sided opener. By default it only DRAFTS — show the user the match and the message, ask if they want to send it, then call again with send:true once they say yes.',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      building: {
+        type: 'string',
+        description:
+          "One line describing what the user is working on this session, inferred from their actual context (files, project, recent work). Specific beats generic — 'realtime auth with WebSockets' matches better than 'a web app'.",
+      },
+      send: {
+        type: 'boolean',
+        description:
+          'Set true ONLY after the user has agreed to send the drafted intro. Delivers the message via the normal DM path.',
+      },
+      handle: {
+        type: 'string',
+        description:
+          'Optional: send to this specific person instead of the auto-matched one (used with send:true when the user picks someone else).',
+      },
+      message: {
+        type: 'string',
+        description:
+          'Optional: override the drafted opener with custom text (used with send:true).',
+      },
+    },
+    required: [],
+  },
+};
+
+async function handler(args = {}) {
+  const initCheck = requireInit();
+  if (initCheck) return initCheck;
+
+  const myHandle = config.getHandle();
+  const { building, send } = args;
+
+  // Fetch who's around and drop self.
+  let others = [];
+  try {
+    const users = await store.getActiveUsers();
+    others = (users || []).filter((u) => u && u.handle && u.handle !== myHandle);
+  } catch (e) {
+    others = [];
+  }
+
+  // ── Send path: user has assented, deliver the intro ───────────────────────
+  if (send === true) {
+    let target = args.handle ? normalizeHandle(args.handle) : null;
+    let message = args.message || null;
+
+    // If no explicit target/message, re-derive the match so send is self-contained.
+    if (!target || !message) {
+      const match =
+        (building && pickRelatedTarget(others, building)) || pickDormantTarget(others);
+      if (!match) {
+        return {
+          display:
+            "No one who lines up is around this second. Try `vibe who` to see everyone, or `vibe ship <what you're building>` so the next person who arrives finds you.",
+        };
+      }
+      target = target || match.handle;
+      message = message || match.opener;
+    }
+
+    const dm = require('./dm');
+    const result = await dm.handler({ handle: target, message });
+    // dm.handler already returns a display + marks firstDmSent on success.
+    if (result && result.display && /failed/i.test(result.display)) return result;
+
+    return {
+      display:
+        `✨ **You're introduced.** Your note just landed in @${target}'s terminal — ` +
+        `you're mid-conversation now, no cold open required.\n\n` +
+        `_When they reply you'll see it here. Want to meet more people? \`vibe who\`._`,
+      _sent: true,
+    };
+  }
+
+  // ── Draft path (default): compose the intro, let the user decide ──────────
+  if (!others.length) {
+    return {
+      display:
+        "Nobody's online right this second to introduce you to. " +
+        "Run `vibe ship <what you're building>` so the next builder who arrives sees your work — " +
+        'or `vibe who` in a bit to check again.',
+    };
+  }
+
+  const related = building ? pickRelatedTarget(others, building) : null;
+  const target = related || pickDormantTarget(others);
+
+  if (!target) {
+    return {
+      display:
+        "There are people around, but I couldn't line anyone up by topic yet. " +
+        '`vibe who` shows everyone online — say hi to whoever looks interesting.',
+    };
+  }
+
+  const sharedTopic =
+    related && related.shared && related.shared.length
+      ? related.shared.slice(0, 2).join(', ')
+      : null;
+
+  const lede = related
+    ? `**✨ Someone you should meet: @${target.handle} is online right now** — ` +
+      (sharedTopic
+        ? `you're both deep in ${sharedTopic}.`
+        : 'looks like a topical match.')
+    : `**👋 @${target.handle} is around right now** — a good first person to meet.`;
+
+  return {
+    display:
+      `${lede}\n\n` +
+      `I drafted an intro from you:\n` +
+      `> ${target.opener}\n\n` +
+      `Want me to send it? Say **yes** and I'll introduce you — or **\`vibe who\`** to browse everyone first.`,
+    _draft: { handle: target.handle, message: target.opener, related: !!related },
+  };
+}
+
+module.exports = { definition, handler };

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,253 @@
+/**
+ * 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.',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      action: {
+        type: 'string',
+        enum: ['attach', 'held', '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. '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 };
+  }
+}
+
+/**
+ * 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,
+    };
+  }
+
+  // ── 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,9 +1,12 @@
 {
-  "version": "0.5.12",
-  "updated": "2026-07-03",
-  "changelog": "First-run just got un-losable. Saying `let's vibe` opens your browser for GitHub sign-in — and now the tool tells you that's happening, hands you a clickable login link if the tab didn't pop, and if anything times out it says exactly what to do (`let's vibe` again) instead of an unrelated hint. No more staring at a silent prompt wondering if it worked.",
+  "version": "0.5.14",
+  "updated": "2026-07-04",
+  "changelog": "New: the Weave. /vibe stops being a place you check and becomes a presence in the session you're already in. Once you sign in, your agent quietly attaches a 'strand' — a distilled read of what you're building — and when someone replies to a thread after you've moved on, Fable drafts your half of the reply in your voice and you send it with one word. You never left the terminal, and the conversation stayed warm.",
   "features": [
-    "Bulletproof first-run — `let's vibe` now 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",
+    "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",
     "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",