slashvibe-mcp 0.2.0 → 0.2.2

package/discord.js

@@ -116,6 +116,24 @@ async function postAnnouncement(message) {
   return post(null, { embed });
 }
 
+/**
+ * Post a conversation highlight
+ */
+async function postHighlight(handle, title, summary, threads = []) {
+  const threadList = threads.length > 0
+    ? '\n\n**Open threads:**\n' + threads.map(t => `• ${t}`).join('\n')
+    : '';
+
+  const embed = {
+    color: 0xF39C12, // Gold/amber for highlights
+    title: `💬 ${title}`,
+    description: summary + threadList,
+    footer: { text: `shared by @${handle} · slashvibe.dev` },
+    timestamp: new Date().toISOString()
+  };
+  return post(null, { embed });
+}
+
 /**
  * Post who's currently online
  */
@@ -147,5 +165,6 @@ module.exports = {
   postActivity,
   postStatus,
   postAnnouncement,
+  postHighlight,
   postOnlineList
 };

package/index.js

@@ -9,10 +9,45 @@
 const presence = require('./presence');
 const config = require('./config');
 const store = require('./store');
+const prompts = require('./prompts');
 
 // Tools that shouldn't show presence footer (would be redundant/noisy)
 const SKIP_FOOTER_TOOLS = ['vibe_init', 'vibe_doctor', 'vibe_test', 'vibe_update'];
 
+// Infer user prompt from tool arguments (for pattern logging)
+function inferPromptFromArgs(toolName, args) {
+  const action = toolName.replace('vibe_', '');
+  const handle = args.handle ? `@${args.handle.replace('@', '')}` : '';
+  const message = args.message ? `"${args.message.slice(0, 50)}..."` : '';
+  const note = args.note || '';
+  const mood = args.mood || '';
+  const reaction = args.reaction || '';
+
+  switch (action) {
+    case 'start': return 'start vibing';
+    case 'who': return 'who is online';
+    case 'ping': return `ping ${handle} ${note}`.trim();
+    case 'react': return `react ${reaction} to ${handle}`.trim();
+    case 'dm': return `message ${handle} ${message}`.trim();
+    case 'inbox': return 'check inbox';
+    case 'open': return `open thread with ${handle}`;
+    case 'status': return `set status to ${mood}`;
+    case 'context': return 'share context';
+    case 'summarize': return 'summarize session';
+    case 'bye': return 'end session';
+    case 'remember': return `remember about ${handle}`;
+    case 'recall': return `recall ${handle}`;
+    case 'forget': return `forget ${handle}`;
+    case 'board': return args.content ? 'post to board' : 'view board';
+    case 'invite': return 'generate invite';
+    case 'echo': return 'send feedback';
+    case 'x_mentions': return 'check x mentions';
+    case 'x_reply': return 'reply on x';
+    case 'handoff': return `handoff task to ${handle}`;
+    default: return `${action} ${handle}`.trim() || null;
+  }
+}
+
 // Generate terminal title escape sequence (OSC 0)
 function getTerminalTitle(onlineCount, unreadCount, lastActivity) {
   const parts = [];
@@ -127,6 +162,8 @@ const tools = {
   vibe_summarize: require('./tools/summarize'),
   vibe_bye: require('./tools/bye'),
   vibe_game: require('./tools/game'),
+  // AIRC Handoff (v1) — context portability
+  vibe_handoff: require('./tools/handoff'),
   // Memory tools (Tier 1 — Collaborative Memory)
   vibe_remember: require('./tools/remember'),
   vibe_recall: require('./tools/recall'),
@@ -145,7 +182,12 @@ const tools = {
   vibe_echo: require('./tools/echo'),
   // X/Twitter bridge
   vibe_x_mentions: require('./tools/x-mentions'),
-  vibe_x_reply: require('./tools/x-reply')
+  vibe_x_reply: require('./tools/x-reply'),
+  // Unified social inbox (Phase 1a)
+  vibe_social_inbox: require('./tools/social-inbox'),
+  vibe_social_post: require('./tools/social-post'),
+  // Language evolution
+  vibe_patterns: require('./tools/patterns')
 };
 
 /**
@@ -196,7 +238,19 @@ class VibeMCPServer {
         }
 
         try {
-          const result = await tool.handler(params.arguments || {});
+          // Log prompt pattern (if _prompt passed) or infer from args
+          const args = params.arguments || {};
+          const inferredPrompt = args._prompt || inferPromptFromArgs(params.name, args);
+          if (inferredPrompt) {
+            prompts.log(inferredPrompt, {
+              tool: params.name,
+              action: params.name.replace('vibe_', ''),
+              target: args.handle || args.to || null,
+              transform: args.format || args.category || null
+            });
+          }
+
+          const result = await tool.handler(args);
 
           // Add ambient presence footer (unless tool is in skip list)
           let footer = '';

package/package.json

@@ -1,6 +1,7 @@
 {
   "name": "slashvibe-mcp",
-  "version": "0.2.0",
+  "version": "0.2.2",
+  "mcpName": "io.github.brightseth/vibe",
   "description": "Social layer for Claude Code - DMs, presence, and connection between AI-assisted developers",
   "main": "index.js",
   "bin": {
@@ -39,6 +40,7 @@
     "memory.js",
     "notify.js",
     "presence.js",
+    "prompts.js",
     "twitter.js",
     "version.json",
     "tools/",

package/prompts.js

@@ -0,0 +1,141 @@
+/**
+ * /vibe Prompt Pattern Logger
+ *
+ * Captures how people ask for things to identify emergent language constructs.
+ * Local-first: ~/.vibe/prompts.jsonl
+ * Server: anonymized patterns for aggregate analysis
+ */
+
+const fs = require('fs');
+const path = require('path');
+const config = require('./config');
+
+const PROMPTS_FILE = path.join(config.VIBE_DIR, 'prompts.jsonl');
+
+/**
+ * Log a prompt and what it resolved to
+ */
+function log(prompt, resolution) {
+  if (!prompt) return;
+
+  const entry = {
+    id: `pr_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 6)}`,
+    ts: new Date().toISOString(),
+    prompt: prompt.slice(0, 500), // Cap length
+    tool: resolution.tool || null,
+    action: resolution.action || null,
+    target: resolution.target || null, // @handle, channel, etc.
+    transform: resolution.transform || null, // emoji, recap, etc.
+  };
+
+  try {
+    fs.appendFileSync(PROMPTS_FILE, JSON.stringify(entry) + '\n');
+  } catch (e) {
+    // Silent fail - logging is best-effort
+  }
+
+  return entry;
+}
+
+/**
+ * Get recent prompts for pattern analysis
+ */
+function getRecent(limit = 50) {
+  try {
+    if (!fs.existsSync(PROMPTS_FILE)) return [];
+
+    const lines = fs.readFileSync(PROMPTS_FILE, 'utf8')
+      .trim()
+      .split('\n')
+      .filter(Boolean);
+
+    return lines
+      .slice(-limit)
+      .map(line => JSON.parse(line))
+      .reverse();
+  } catch (e) {
+    return [];
+  }
+}
+
+/**
+ * Extract patterns from logged prompts
+ * Returns frequency map of normalized patterns
+ */
+function extractPatterns() {
+  const prompts = getRecent(200);
+  const patterns = {};
+
+  for (const p of prompts) {
+    // Normalize: lowercase, replace @handles with @*, replace quoted strings with "*"
+    let normalized = p.prompt.toLowerCase()
+      .replace(/@\w+/g, '@*')
+      .replace(/"[^"]+"/g, '"*"')
+      .replace(/'[^']+'/g, "'*'")
+      .trim();
+
+    patterns[normalized] = (patterns[normalized] || 0) + 1;
+  }
+
+  // Sort by frequency
+  return Object.entries(patterns)
+    .sort((a, b) => b[1] - a[1])
+    .slice(0, 20)
+    .map(([pattern, count]) => ({ pattern, count }));
+}
+
+/**
+ * Suggest commands based on frequent patterns
+ */
+function suggestConstructs() {
+  const patterns = extractPatterns();
+  const suggestions = [];
+
+  for (const { pattern, count } of patterns) {
+    if (count < 3) continue; // Need repetition to suggest
+
+    // Pattern matching for common constructs
+    if (pattern.includes('share') && pattern.includes('discord')) {
+      suggestions.push({ pattern, construct: 'vibe discord <content>', count });
+    }
+    if (pattern.includes('emoji') && pattern.includes('poem')) {
+      suggestions.push({ pattern, construct: 'vibe poem <content>', count });
+    }
+    if (pattern.includes('menu') || pattern.includes('options')) {
+      suggestions.push({ pattern, construct: 'vibe menu', count });
+    }
+    if (pattern.includes('recap') || pattern.includes('summary')) {
+      suggestions.push({ pattern, construct: 'vibe recap @handle', count });
+    }
+    if (pattern.includes('everyone') || pattern.includes('broadcast')) {
+      suggestions.push({ pattern, construct: 'vibe broadcast <message>', count });
+    }
+  }
+
+  return suggestions;
+}
+
+/**
+ * Anonymize and prepare for server upload
+ */
+function getAnonymizedPatterns() {
+  const patterns = extractPatterns();
+
+  return patterns.map(({ pattern, count }) => ({
+    pattern,
+    frequency: count,
+    // Remove any potentially identifying info
+    normalized: pattern
+      .replace(/\d+/g, 'N')
+      .replace(/[a-f0-9]{8,}/gi, 'HASH')
+  }));
+}
+
+module.exports = {
+  log,
+  getRecent,
+  extractPatterns,
+  suggestConstructs,
+  getAnonymizedPatterns,
+  PROMPTS_FILE
+};

package/tools/handoff.js

@@ -0,0 +1,239 @@
+/**
+ * vibe handoff — Transfer task context to another agent
+ *
+ * AIRC Handoff v1: The atomic unit of agent work.
+ * Enables context portability and non-session-bound tasks.
+ */
+
+const config = require('../config');
+const store = require('../store');
+const { requireInit, normalizeHandle, warning } = require('./_shared');
+const { actions, formatActions } = require('./_actions');
+
+// Handoff schema version
+const HANDOFF_VERSION = '1.0';
+
+const definition = {
+  name: 'vibe_handoff',
+  description: `Hand off a task to another agent with full context. Use when:
+- You're stuck and need another agent to continue
+- Shifting to a different domain/expertise
+- Ending your session but work needs to continue
+- Delegating a subtask
+
+The receiving agent gets structured context to resume work immediately.`,
+  inputSchema: {
+    type: 'object',
+    properties: {
+      to: {
+        type: 'string',
+        description: 'Who to hand off to (e.g., @gene_agent)'
+      },
+      task: {
+        type: 'object',
+        description: 'The task being handed off',
+        properties: {
+          title: {
+            type: 'string',
+            description: 'Brief task title (e.g., "Fix auth token refresh bug")'
+          },
+          intent: {
+            type: 'string',
+            description: 'What you were trying to accomplish'
+          },
+          priority: {
+            type: 'string',
+            enum: ['low', 'medium', 'high', 'critical'],
+            description: 'Task priority'
+          }
+        },
+        required: ['title', 'intent']
+      },
+      context: {
+        type: 'object',
+        description: 'Technical context for the task',
+        properties: {
+          repo: {
+            type: 'string',
+            description: 'Git repository URL or identifier'
+          },
+          branch: {
+            type: 'string',
+            description: 'Current branch'
+          },
+          files: {
+            type: 'array',
+            items: {
+              type: 'object',
+              properties: {
+                path: { type: 'string' },
+                lines: { type: 'string', description: 'Line range (e.g., "138-155")' },
+                note: { type: 'string', description: 'What this file is about' }
+              }
+            },
+            description: 'Relevant files with notes'
+          },
+          current_state: {
+            type: 'string',
+            description: 'What has been done so far'
+          },
+          next_step: {
+            type: 'string',
+            description: 'The immediate next action needed'
+          },
+          blockers: {
+            type: 'array',
+            items: { type: 'string' },
+            description: 'Any blockers or open questions'
+          }
+        },
+        required: ['current_state', 'next_step']
+      },
+      history_summary: {
+        type: 'string',
+        description: 'Brief summary of investigation/work done (prevents context loss)'
+      }
+    },
+    required: ['to', 'task', 'context']
+  }
+};
+
+async function handler(args) {
+  const initCheck = requireInit();
+  if (initCheck) return initCheck;
+
+  const { to, task, context, history_summary } = args;
+  const myHandle = config.getHandle();
+  const them = normalizeHandle(to);
+
+  if (them === myHandle) {
+    return { display: 'Cannot hand off to yourself.' };
+  }
+
+  // Validate required fields
+  if (!task?.title || !task?.intent) {
+    return { display: 'Task requires title and intent.' };
+  }
+  if (!context?.current_state || !context?.next_step) {
+    return { display: 'Context requires current_state and next_step.' };
+  }
+
+  // Generate handoff ID
+  const handoff_id = `handoff_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+
+  // Build the handoff payload (AIRC Handoff v1 schema)
+  const handoffPayload = {
+    type: 'handoff',
+    version: HANDOFF_VERSION,
+    handoff_id,
+    timestamp: new Date().toISOString(),
+
+    task: {
+      title: task.title,
+      intent: task.intent,
+      priority: task.priority || 'medium'
+    },
+
+    context: {
+      repo: context.repo || null,
+      branch: context.branch || null,
+      files: context.files || [],
+      current_state: context.current_state,
+      next_step: context.next_step,
+      blockers: context.blockers || [],
+    },
+
+    history: {
+      summary: history_summary || 'No history provided'
+    }
+  };
+
+  // Build human-readable message for the recipient
+  const humanMessage = formatHandoffMessage(handoffPayload, myHandle);
+
+  // Send via existing message system with structured payload
+  await store.sendMessage(
+    myHandle,
+    them,
+    humanMessage,
+    'handoff',
+    handoffPayload
+  );
+
+  // Build response
+  const filesCount = context.files?.length || 0;
+  let display = `**Handed off to @${them}**\n\n`;
+  display += `Task: ${task.title}\n`;
+  display += `Priority: ${task.priority || 'medium'}\n`;
+  if (context.repo) display += `Repo: ${context.repo}\n`;
+  if (filesCount > 0) display += `Files: ${filesCount} tracked\n`;
+  display += `\nNext step for @${them}:\n> ${context.next_step}`;
+
+  if (context.blockers?.length > 0) {
+    display += `\n\nBlockers:\n`;
+    context.blockers.forEach(b => {
+      display += `- ${b}\n`;
+    });
+  }
+
+  display += `\n\n_Handoff ID: ${handoff_id}_`;
+
+  return {
+    display,
+    hint: 'handoff_sent',
+    handoff_id,
+    to: them,
+    actions: formatActions([
+      { label: 'check inbox', command: 'vibe inbox' },
+      { label: 'end session', command: 'vibe bye' }
+    ])
+  };
+}
+
+/**
+ * Format handoff as human-readable message
+ */
+function formatHandoffMessage(payload, from) {
+  const { task, context, history } = payload;
+
+  let msg = `HANDOFF from @${from}\n\n`;
+  msg += `TASK: ${task.title}\n`;
+  msg += `PRIORITY: ${task.priority}\n`;
+  msg += `INTENT: ${task.intent}\n\n`;
+
+  if (context.repo) {
+    msg += `REPO: ${context.repo}`;
+    if (context.branch) msg += ` (${context.branch})`;
+    msg += '\n';
+  }
+
+  if (context.files?.length > 0) {
+    msg += '\nFILES:\n';
+    context.files.forEach(f => {
+      msg += `- ${f.path}`;
+      if (f.lines) msg += ` [${f.lines}]`;
+      if (f.note) msg += `: ${f.note}`;
+      msg += '\n';
+    });
+  }
+
+  msg += `\nCURRENT STATE:\n${context.current_state}\n`;
+  msg += `\nNEXT STEP:\n${context.next_step}\n`;
+
+  if (context.blockers?.length > 0) {
+    msg += '\nBLOCKERS:\n';
+    context.blockers.forEach(b => {
+      msg += `- ${b}\n`;
+    });
+  }
+
+  if (history.summary && history.summary !== 'No history provided') {
+    msg += `\nHISTORY:\n${history.summary}\n`;
+  }
+
+  msg += '\n---\nReply to accept and continue this work.';
+
+  return msg;
+}
+
+module.exports = { definition, handler };

package/tools/patterns.js

@@ -0,0 +1,79 @@
+/**
+ * vibe patterns — View emerging language constructs
+ *
+ * Shows frequent prompt patterns and suggests new commands.
+ */
+
+const prompts = require('../prompts');
+
+const definition = {
+  name: 'vibe_patterns',
+  description: 'View emerging language patterns from how people use /vibe. Shows frequent prompts and suggests new commands.',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      limit: {
+        type: 'number',
+        description: 'Number of recent prompts to analyze (default: 50)'
+      },
+      raw: {
+        type: 'boolean',
+        description: 'Show raw prompts instead of patterns'
+      }
+    }
+  }
+};
+
+async function handler({ limit = 50, raw = false }) {
+  if (raw) {
+    // Show raw recent prompts
+    const recent = prompts.getRecent(limit);
+
+    if (recent.length === 0) {
+      return {
+        display: `## Prompt Log\n\n_No prompts logged yet. Use /vibe and patterns will emerge._\n\nFile: \`${prompts.PROMPTS_FILE}\``
+      };
+    }
+
+    let display = `## Recent Prompts (${recent.length})\n\n`;
+    display += '| Time | Prompt | Tool |\n';
+    display += '|------|--------|------|\n';
+
+    for (const p of recent.slice(0, 20)) {
+      const time = new Date(p.ts).toLocaleTimeString('en-US', { hour: '2-digit', minute: '2-digit' });
+      const prompt = p.prompt.slice(0, 40) + (p.prompt.length > 40 ? '...' : '');
+      display += `| ${time} | ${prompt} | ${p.tool || '-'} |\n`;
+    }
+
+    display += `\n---\n_${recent.length} total logged · ${prompts.PROMPTS_FILE}_`;
+    return { display };
+  }
+
+  // Show patterns and suggestions
+  const patterns = prompts.extractPatterns();
+  const suggestions = prompts.suggestConstructs();
+
+  let display = '## Emerging Patterns\n\n';
+
+  if (patterns.length === 0) {
+    display += '_Not enough data yet. Keep using /vibe and patterns will emerge._\n';
+  } else {
+    display += '**Frequent patterns:**\n';
+    for (const { pattern, count } of patterns.slice(0, 10)) {
+      display += `- \`${pattern}\` (${count}x)\n`;
+    }
+  }
+
+  if (suggestions.length > 0) {
+    display += '\n**Suggested constructs:**\n';
+    for (const { pattern, construct, count } of suggestions) {
+      display += `- \`${construct}\` ← from "${pattern}" (${count}x)\n`;
+    }
+  }
+
+  display += `\n---\n_Run \`vibe patterns --raw\` to see individual prompts_`;
+
+  return { display };
+}
+
+module.exports = { definition, handler };

package/tools/social-inbox.js

@@ -0,0 +1,180 @@
+/**
+ * vibe social-inbox — Unified social inbox across all channels
+ *
+ * Reads from the local cache (sync-then-read pattern) for instant access.
+ * Use --refresh to trigger a sync.
+ */
+
+const { requireInit, header, divider, formatTimeAgo } = require('./_shared');
+
+const API_URL = process.env.VIBE_API_URL || 'https://slashvibe.dev';
+
+const definition = {
+  name: 'vibe_social_inbox',
+  description: 'See messages across all connected social channels (X, Farcaster, etc.)',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      channel: {
+        type: 'string',
+        enum: ['all', 'x', 'farcaster', 'discord', 'telegram', 'whatsapp', 'email'],
+        description: 'Filter by channel (default: all)'
+      },
+      high_signal: {
+        type: 'boolean',
+        description: 'Show only high-signal messages like mentions/DMs (default: true)'
+      },
+      limit: {
+        type: 'number',
+        description: 'Number of messages to show (default: 20, max: 100)'
+      },
+      refresh: {
+        type: 'boolean',
+        description: 'Force sync from external APIs (default: false)'
+      },
+      status: {
+        type: 'boolean',
+        description: 'Show channel connection status (default: false)'
+      }
+    }
+  }
+};
+
+async function handler(args) {
+  const initCheck = requireInit();
+  if (initCheck) return initCheck;
+
+  const {
+    channel = 'all',
+    high_signal = true,
+    limit = 20,
+    refresh = false,
+    status = false
+  } = args;
+
+  try {
+    // Build query params
+    const params = new URLSearchParams();
+    if (channel !== 'all') params.set('channel', channel);
+    if (!high_signal) params.set('high_signal', 'false');
+    if (limit) params.set('limit', limit.toString());
+    if (refresh) params.set('refresh', 'true');
+    if (status) params.set('status', 'true');
+
+    const url = `${API_URL}/api/social?${params}`;
+
+    const response = await fetch(url);
+    const data = await response.json();
+
+    if (!data.success) {
+      return { display: `${header('Social Inbox')}\n\n_Error:_ ${data.error}` };
+    }
+
+    // Status view
+    if (status) {
+      let display = header('Channel Status');
+      display += '\n\n';
+
+      for (const [ch, info] of Object.entries(data.channels || {})) {
+        const icon = info.status?.status === 'connected' ? '✅' : '❌';
+        const configured = info.configured ? 'configured' : 'not configured';
+        display += `${icon} **${ch}** — ${configured}\n`;
+
+        if (info.status?.error) {
+          display += `   _${info.status.error}_\n`;
+        }
+
+        if (info.capabilities) {
+          const caps = [];
+          if (info.capabilities.read) caps.push('read');
+          if (info.capabilities.write) caps.push('write');
+          if (info.capabilities.dm) caps.push('dm');
+          display += `   Capabilities: ${caps.join(', ')}\n`;
+        }
+        display += '\n';
+      }
+
+      return { display };
+    }
+
+    // Inbox view
+    const messages = data.messages || [];
+
+    if (messages.length === 0) {
+      let display = header('Social Inbox');
+      display += '\n\n';
+
+      if (data.summary?.total === 0) {
+        display += '_No messages synced yet._\n\n';
+        display += 'Run `vibe social-inbox --status` to check channel connections.\n';
+        display += 'Run `vibe social-inbox --refresh` to trigger a sync.';
+      } else {
+        display += `_No ${channel === 'all' ? '' : channel + ' '}messages found._`;
+      }
+
+      return { display };
+    }
+
+    // Format messages
+    let display = header(`Social Inbox (${messages.length})`);
+    display += '\n\n';
+
+    // Group by channel for summary
+    const byChannel = {};
+    for (const msg of messages) {
+      byChannel[msg.channel] = (byChannel[msg.channel] || 0) + 1;
+    }
+
+    const channelSummary = Object.entries(byChannel)
+      .map(([ch, count]) => `${ch}: ${count}`)
+      .join(' | ');
+    display += `📬 ${channelSummary}\n`;
+    display += divider();
+    display += '\n';
+
+    // Show messages
+    for (const msg of messages) {
+      const channelIcon = getChannelIcon(msg.channel);
+      const typeIcon = getTypeIcon(msg.type);
+
+      display += `${channelIcon} **@${msg.from}** ${typeIcon} — _${msg.timeAgo}_\n`;
+      display += `${msg.content}\n`;
+      display += `_[${msg.channel}:${msg.id.split(':')[1]?.slice(0, 8)}]_\n\n`;
+    }
+
+    display += divider();
+    display += 'Reply: `vibe post "message" --x --farcaster`';
+
+    return { display };
+
+  } catch (e) {
+    return {
+      display: `${header('Social Inbox')}\n\n_Error:_ ${e.message}`
+    };
+  }
+}
+
+function getChannelIcon(channel) {
+  const icons = {
+    x: '𝕏',
+    farcaster: '🟣',
+    discord: '💬',
+    telegram: '✈️',
+    whatsapp: '💚',
+    email: '📧'
+  };
+  return icons[channel] || '📱';
+}
+
+function getTypeIcon(type) {
+  const icons = {
+    mention: '@',
+    reply: '↩️',
+    dm: '✉️',
+    like: '❤️',
+    repost: '🔁'
+  };
+  return icons[type] || '';
+}
+
+module.exports = { definition, handler };

package/tools/social-post.js

@@ -0,0 +1,141 @@
+/**
+ * vibe social-post — Post to multiple social channels at once
+ *
+ * Multi-cast posting with dry-run preview support.
+ */
+
+const { requireInit, header, divider, warning } = require('./_shared');
+
+const API_URL = process.env.VIBE_API_URL || 'https://slashvibe.dev';
+
+const definition = {
+  name: 'vibe_social_post',
+  description: 'Post content to one or more social channels (X, Farcaster, etc.)',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      content: {
+        type: 'string',
+        description: 'The content to post'
+      },
+      channels: {
+        type: 'array',
+        items: { type: 'string' },
+        description: 'Channels to post to (e.g., ["x", "farcaster"])'
+      },
+      dry_run: {
+        type: 'boolean',
+        description: 'Preview post without sending (default: false)'
+      },
+      reply_to: {
+        type: 'string',
+        description: 'Message ID to reply to (e.g., "x:1234567890")'
+      }
+    },
+    required: ['content', 'channels']
+  }
+};
+
+async function handler(args) {
+  const initCheck = requireInit();
+  if (initCheck) return initCheck;
+
+  const { content, channels, dry_run, reply_to } = args;
+
+  // Validation
+  if (!content || typeof content !== 'string' || content.trim().length === 0) {
+    return { display: 'Need content to post.' };
+  }
+
+  if (!channels || !Array.isArray(channels) || channels.length === 0) {
+    return { display: 'Need at least one channel. Options: x, farcaster' };
+  }
+
+  const trimmed = content.trim();
+
+  // Character limit warnings
+  const warnings = [];
+  if (channels.includes('x') && trimmed.length > 280) {
+    warnings.push(`X: Content is ${trimmed.length} chars (max 280). Will be truncated.`);
+  }
+
+  try {
+    const response = await fetch(`${API_URL}/api/social`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        content: trimmed,
+        channels,
+        dry_run: dry_run || false,
+        reply_to
+      })
+    });
+
+    const data = await response.json();
+
+    if (!data.success && !data.dry_run) {
+      return { display: `${header('Post Failed')}\n\n_Error:_ ${data.error}` };
+    }
+
+    // Dry run preview
+    if (data.dry_run) {
+      let display = header('Post Preview (Dry Run)');
+      display += '\n\n';
+
+      for (const [ch, preview] of Object.entries(data.previews || {})) {
+        const icon = preview.configured ? '✅' : '❌';
+        const canPost = preview.canWrite ? 'can post' : 'read-only';
+
+        display += `${icon} **${ch}** — ${canPost}\n`;
+
+        if (!preview.configured) {
+          display += `   _Not configured_\n`;
+        } else if (preview.wouldTruncate) {
+          display += `   ⚠️ Content will be truncated to 280 chars\n`;
+        }
+
+        display += `   "${preview.content.slice(0, 100)}${preview.content.length > 100 ? '...' : ''}"\n\n`;
+      }
+
+      display += divider();
+      display += 'Remove `--dry_run` to post for real.';
+
+      return { display };
+    }
+
+    // Actual post results
+    let display = header('Posted');
+    display += '\n\n';
+
+    if (warnings.length > 0) {
+      display += warning(warnings.join('\n')) + '\n\n';
+    }
+
+    let anySuccess = false;
+    for (const [ch, result] of Object.entries(data.results || {})) {
+      if (result.success) {
+        anySuccess = true;
+        display += `✅ **${ch}** — Posted!\n`;
+        if (result.url) {
+          display += `   🔗 ${result.url}\n`;
+        }
+      } else {
+        display += `❌ **${ch}** — Failed: ${result.error}\n`;
+      }
+      display += '\n';
+    }
+
+    if (!anySuccess) {
+      display += '\n_No posts succeeded. Check channel configuration._';
+    }
+
+    return { display };
+
+  } catch (e) {
+    return {
+      display: `${header('Post Error')}\n\n_Error:_ ${e.message}`
+    };
+  }
+}
+
+module.exports = { definition, handler };