slashvibe-mcp 0.5.14 → 0.5.16

package/index.js

@@ -256,6 +256,11 @@ const coreTools = {
   // terminal (Spec 1); "Fable holds your half" surfaces via action:'held' + vibe_start.
   vibe_weave: require('./tools/weave'),
 
+  // The Weave, deepest form (Spec 4) — co-author a living shared artifact with
+  // another viber; Fable merges edits + flags conflicts with judgment across
+  // both terminals. Built on the vibe_play/vibe_corpse shared-state-over-DM lineage.
+  vibe_fable: require('./tools/fable'),
+
   // 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.14",
+  "version": "0.5.16",
   "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/fable.js

@@ -0,0 +1,283 @@
+/**
+ * vibe fable — a shared, living artifact two builders co-author (Spec 4 of
+ * RFC_THE_WEAVE.md). The deepest weave.
+ *
+ * Two people working toward the same thing — a spec, a design, an API contract,
+ * a plan — don't trade messages here. They co-author ONE living object from their
+ * separate terminals, and Fable (your in-session model) keeps it coherent: it
+ * folds each new contribution into the merged body, flags where two edits
+ * genuinely collide, and narrates the delta into the other person's session.
+ *
+ * The magic is the thing only Fable can do: hold a coherent shared mental model
+ * of two people's divergent work and reconcile it *with judgment* ("martin's
+ * ordering is safer — no unauthenticated room state"). No shared-doc tool reasons
+ * about which design is better. This tool does not merge for you — it hands you
+ * the current body + what the other side just added, and asks YOU to weave.
+ *
+ * Transport lineage: this is the grown-up sibling of vibe_play/vibe_corpse —
+ * shared state, but instead of ping-pong turns it's ONE converging artifact, and
+ * instead of opaque state the medium (you) actively reconciles it. The durable
+ * object lives server-side (/api/weave/fable); a DM ping rides the normal thread
+ * so the update lands in the collaborator's terminal — the fable is the point,
+ * the chat is the exhaust.
+ */
+
+const config = require('../config');
+const store = require('../store');
+const { requireInit, normalizeHandle, formatTimeAgo, truncate } = require('./_shared');
+
+const definition = {
+  name: 'vibe_fable',
+  description:
+    'Co-author a living shared artifact with another viber — a spec, design, plan, or contract you both shape from your own terminals, and Fable (you) keeps coherent. ' +
+    "This is NOT chat: it's ONE converging object both sides edit, where you merge contributions and flag genuine conflicts with judgment. " +
+    "Actions: `open` (start/find a fable — pass `title` and `with:[handle]`); `read` (pull the current body + what the other side added since you last looked — do this before weaving); " +
+    "`weave` (fold a contribution in: pass `text` = what the user is adding, `note` = the plain-language delta to narrate to the collaborator, `body` = the FULL updated merged artifact after you reconcile, `conflicts` = [{summary}] where two edits truly collide, `resolve` = [conflictId] a decision closed); `list` (the user's fables). " +
+    'YOU are Fable at read time: when you `read` and see the other side changed something that clashes with the current body, reconcile it with judgment, write the merged `body`, and flag the collision as a `conflict` with your reasoning — never silently overwrite their work, never invent agreement that isn\'t there.',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      action: {
+        type: 'string',
+        enum: ['open', 'read', 'weave', 'list'],
+        description:
+          "'open': create or find a fable (needs title + with). 'read': pull current body + the other side's new contributions (do before weaving). 'weave': fold in a contribution / merged body / conflicts. 'list': the user's active fables.",
+      },
+      id: { type: 'string', description: 'The fable id (from open/list). Required for read and weave.' },
+      title: { type: 'string', description: "What you're co-authoring, e.g. 'airc handshake v2'. Required for open." },
+      with: {
+        type: 'array',
+        items: { type: 'string' },
+        description: 'Handle(s) of the collaborator(s), e.g. ["@martingrasser"]. Required for open.',
+      },
+      text: { type: 'string', description: "weave: the raw contribution the user is adding this turn (their intent, in their words)." },
+      note: { type: 'string', description: 'weave: a plain-language line narrating this delta to the collaborator — what changed and why. Lands in their terminal.' },
+      body: {
+        type: 'string',
+        description:
+          'weave: the FULL updated merged artifact after you reconcile the new contribution into it. This is the coherent shared object — always send the whole thing, not a fragment.',
+      },
+      conflicts: {
+        type: 'array',
+        items: { type: 'object' },
+        description:
+          "weave: collisions you judged between two edits, each {summary: 'you have join→challenge; martin has challenge→join — his is safer'}. Flag, don't silently pick.",
+      },
+      resolve: {
+        type: 'array',
+        items: { type: 'string' },
+        description: 'weave: ids of conflicts a decision has now closed.',
+      },
+    },
+    required: [],
+  },
+};
+
+function apiBase() {
+  return config.getApiUrl();
+}
+
+// All fable state changes go through one authed endpoint; actor is derived
+// server-side from the token (never a body handle). We only send the payload.
+async function postFable(payload) {
+  const token = config.getAuthToken();
+  if (!token) return { ok: false, error: 'no_token' };
+  try {
+    const resp = await fetch(`${apiBase()}/api/weave/fable`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        Authorization: `Bearer ${token}`,
+      },
+      body: JSON.stringify(payload),
+    });
+    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 };
+  }
+}
+
+// Ride the DM thread so a fable update surfaces in the collaborator's terminal.
+// The payload tags it so their session recognizes "open the fable, don't reply."
+async function pingCollaborators(me, handles, fable, note) {
+  const title = fable.title || 'our fable';
+  const line = note ? truncate(note, 240) : `updated our fable "${title}"`;
+  const body =
+    `📖 ${line}\n\n▸ this is our shared fable "${title}" — open it with \`vibe_fable read\` (id: ${fable.id}) ` +
+    `to see the merged version and weave your part.`;
+  await Promise.all(
+    (handles || []).map((h) =>
+      store
+        .sendMessage(me, normalizeHandle(h), body, 'dm', {
+          type: 'fable',
+          id: fable.id,
+          title,
+          version: fable.version,
+        })
+        .catch(() => {})
+    )
+  );
+}
+
+// Render the reader-facing view of a fable: the merged body, what the other side
+// just added (the delta to reconcile), and any open conflicts awaiting a call.
+function renderFable(f, { forWeaving } = {}) {
+  const withWho = (f.with || []).map((h) => `@${h}`).join(', ') || 'someone';
+  let out = `## 📖 ${f.title}\n_with ${withWho} · v${f.version || 0}`;
+  if (f.updated_at) out += ` · updated ${formatTimeAgo(f.updated_at)}`;
+  out += `_\n\n`;
+
+  out += `**the fable so far:**\n`;
+  out += f.body ? `\n${f.body}\n` : `_(empty — nothing woven yet; you write the first version)_\n`;
+
+  const news = Array.isArray(f.new_intents) ? f.new_intents : [];
+  if (news.length) {
+    out += `\n---\n**${news.length} new from the other side since you last looked — reconcile these:**\n`;
+    for (const it of news) {
+      const who = it.by ? `@${it.by}` : 'they';
+      out += `\n• ${who}: ${truncate(it.text || it.note || '', 400)}`;
+    }
+  }
+
+  const conflicts = Array.isArray(f.open_conflicts) ? f.open_conflicts : [];
+  if (conflicts.length) {
+    out += `\n\n---\n**⚠️ open conflicts (a call is needed):**\n`;
+    for (const c of conflicts) {
+      out += `\n• [${c.id}] ${truncate(c.summary || '', 300)}`;
+    }
+  }
+
+  return out;
+}
+
+async function handler(args = {}) {
+  const initCheck = requireInit();
+  if (initCheck) return initCheck;
+
+  const me = config.getHandle();
+  const action = args.action || (args.id ? 'read' : args.title ? 'open' : 'list');
+
+  const unauth = (err) =>
+    err === 'no_token' || err === 'unauthenticated'
+      ? { display: "⚠️ Couldn't reach the weave — your /vibe session isn't authenticated. Run `vibe init` first." }
+      : null;
+
+  // ── list ──────────────────────────────────────────────────────────────────
+  if (action === 'list') {
+    const result = await postFable({ action: 'list' });
+    if (!result.ok) return unauth(result.error) || { display: `⚠️ Couldn't list fables (${result.error}).` };
+    const fables = result.data.fables || [];
+    if (!fables.length) {
+      return {
+        display:
+          "No shared fables yet. Start one with someone you're building alongside:\n" +
+          '`vibe_fable open --title "airc handshake v2" --with @martingrasser`\n\n' +
+          'A fable is one living artifact you both shape — Fable keeps it coherent across your two terminals.',
+      };
+    }
+    const lines = fables.map((f) => {
+      const withWho = (f.with || []).map((h) => `@${h}`).join(', ');
+      return `• **${f.title}** _(with ${withWho}${f.updated_at ? ` · ${formatTimeAgo(f.updated_at)}` : ''})_ — id: ${f.id}`;
+    });
+    return {
+      display:
+        `## 📖 your fables\n\n${lines.join('\n')}\n\n` +
+        `Open one with \`vibe_fable read\` (pass its id) to see the merged artifact and weave.`,
+    };
+  }
+
+  // ── open ──────────────────────────────────────────────────────────────────
+  if (action === 'open') {
+    const title = (args.title || '').trim();
+    const withList = Array.isArray(args.with) ? args.with : args.with ? [args.with] : [];
+    if (!title) return { display: 'Give the fable a title — what are you co-authoring? `vibe_fable open --title "…" --with @handle`' };
+    if (!withList.length) return { display: 'Who are you co-authoring with? `vibe_fable open --title "…" --with @handle`' };
+
+    const result = await postFable({ action: 'open', title, with: withList });
+    if (!result.ok) {
+      if (unauth(result.error)) return unauth(result.error);
+      if (result.error === 'need_a_human_collaborator') {
+        return { display: `Couldn't open the fable — @${normalizeHandle(withList[0])} isn't a viber you can co-author with. Invite a real human on /vibe.` };
+      }
+      return { display: `⚠️ Couldn't open the fable (${result.error}).` };
+    }
+    const f = result.data.fable;
+    // Let the collaborator know a shared space now exists in their terminal.
+    await pingCollaborators(me, f.with, f, `opened a shared fable: "${f.title}"`);
+    return {
+      display:
+        renderFable(f) +
+        `\n\n---\n**You're in a fable now.** This is one shared artifact, not a chat. ` +
+        `Write the opening version of "${f.title}" as the \`body\`, add a \`note\` for ${(f.with || []).map((h) => `@${h}`).join(', ')}, ` +
+        `and \`weave\` it in. As they contribute, \`read\` to see their edits and reconcile them into the body — flagging any real conflict with your judgment.`,
+      _fable: f,
+    };
+  }
+
+  // ── read ──────────────────────────────────────────────────────────────────
+  if (action === 'read') {
+    if (!args.id) return { display: 'Which fable? Pass its `id` (see `vibe_fable list`).' };
+    const result = await postFable({ action: 'read', id: args.id });
+    if (!result.ok) {
+      if (unauth(result.error)) return unauth(result.error);
+      if (result.error === 'not_found') return { display: "That fable doesn't exist (or expired). `vibe_fable list` to see your active ones." };
+      if (result.error === 'not_a_participant') return { display: "That fable isn't one you're part of." };
+      return { display: `⚠️ Couldn't read the fable (${result.error}).` };
+    }
+    const f = result.data.fable;
+    const news = Array.isArray(f.new_intents) ? f.new_intents : [];
+    const conflicts = Array.isArray(f.open_conflicts) ? f.open_conflicts : [];
+
+    let coach = '';
+    if (news.length || conflicts.length) {
+      coach =
+        `\n\n---\n**You are Fable here.** ` +
+        (news.length
+          ? `Reconcile the ${news.length} new contribution${news.length > 1 ? 's' : ''} into the body: where it fits, fold it in; where it genuinely clashes with what's there, flag a \`conflict\` with your judgment on which is better and why — don't silently overwrite. `
+          : '') +
+        (conflicts.length ? `Resolve the open conflict${conflicts.length > 1 ? 's' : ''} if a call is now clear (\`resolve:[id]\`). ` : '') +
+        `Then write the FULL merged \`body\` and \`weave\` it back with a \`note\` narrating what changed. Never invent agreement that isn't there.`;
+    } else {
+      coach = `\n\n---\nNothing new from the other side since you last looked. Add to it anytime: \`weave\` a new \`body\` + \`note\`.`;
+    }
+    return { display: renderFable(f, { forWeaving: true }) + coach, _fable: f };
+  }
+
+  // ── weave ─────────────────────────────────────────────────────────────────
+  if (action === 'weave') {
+    if (!args.id) return { display: 'Which fable? Pass its `id` (see `vibe_fable list`).' };
+    const payload = {
+      action: 'weave',
+      id: args.id,
+      text: args.text || '',
+      note: args.note || '',
+    };
+    if (typeof args.body === 'string') payload.body = args.body;
+    if (Array.isArray(args.conflicts)) payload.conflicts = args.conflicts;
+    if (Array.isArray(args.resolve)) payload.resolve = args.resolve;
+
+    const result = await postFable(payload);
+    if (!result.ok) {
+      if (unauth(result.error)) return unauth(result.error);
+      if (result.error === 'not_found') return { display: "That fable doesn't exist (or expired)." };
+      if (result.error === 'not_a_participant') return { display: "That fable isn't one you're part of." };
+      if (result.error === 'nothing_to_weave') return { display: 'Nothing to weave — pass a `body`, `note`, `text`, `conflicts`, or `resolve`.' };
+      return { display: `⚠️ Couldn't weave (${result.error}).` };
+    }
+    const f = result.data.fable;
+    const notify = result.data.notify || f.with || [];
+    // Narrate the delta into the collaborator's terminal via the DM thread.
+    await pingCollaborators(me, notify, f, args.note || `wove into "${f.title}"`);
+
+    let tail = `\n\n---\n✓ Woven (v${f.version}) and narrated to ${(notify || []).map((h) => `@${h}`).join(', ') || 'your collaborator'}.`;
+    const openC = Array.isArray(f.open_conflicts) ? f.open_conflicts.length : 0;
+    if (openC) tail += ` ${openC} conflict${openC > 1 ? 's' : ''} still open — surface ${openC > 1 ? 'them' : 'it'} to the user for a call.`;
+    return { display: renderFable(f) + tail, _fable: f };
+  }
+
+  return { display: 'Unknown fable action. Use open / read / weave / list.' };
+}
+
+module.exports = { definition, handler };

package/tools/weave.js

@@ -30,15 +30,16 @@ const definition = {
     '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:"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', 'quiet'],
+        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. 'quiet': leave the weave (removes your strand).",
+          "'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',
@@ -97,6 +98,30 @@ async function postStrand({ digest, posture }) {
   }
 }
 
+// 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
@@ -198,6 +223,67 @@ async function handler(args = {}) {
     };
   }
 
+  // ── 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' });

package/version.json

@@ -1,8 +1,10 @@
 {
-  "version": "0.5.14",
+  "version": "0.5.16",
   "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.",
+  "changelog": "The deepest weave yet: co-author a living shared artifact with another builder. A spec, a design, a plan you BOTH shape from your own terminals — and Fable keeps it coherent, folding each side's edits into one merged version and flagging where you genuinely disagree *with judgment* (\"you have join→challenge; martin has challenge→join — his is safer\"). No shared-doc tool reasons about which design is better. Start one with `vibe_fable open`.",
   "features": [
+    "Shared fable (vibe_fable) — co-author ONE living artifact with another viber across two terminals: a spec, design, or plan you both edit. Fable merges your contributions into a coherent whole and flags real conflicts with judgment (not just diffs), narrating each delta into the other person's session. This is NOT chat — it's the thing you're building, and the chat is the exhaust",
+    "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",