@sym-bot/mesh-channel 0.1.23 → 0.2.0

package/.claude-plugin/marketplace.json

@@ -5,15 +5,15 @@
     "email": "info@sym.bot"
   },
   "metadata": {
-    "description": "Real-time Claude-to-Claude mesh. Peer-to-peer cognitive signals over Bonjour LAN or WebSocket relay.",
-    "version": "0.1.23"
+    "description": "Real-time Claude-to-Claude mesh. Agent-to-agent cognitive signals over Bonjour LAN or WebSocket relay.",
+    "version": "0.2.0"
   },
   "plugins": [
     {
       "name": "sym-mesh-channel",
       "source": "./",
-      "description": "Real-time Claude-to-Claude mesh. Peer-to-peer cognitive signals over Bonjour LAN or WebSocket relay. Implements the Mesh Memory Protocol (MMP) for structured cognitive state exchange between Claude Code sessions.",
-      "version": "0.1.23",
+      "description": "Real-time Claude-to-Claude mesh. Agent-to-agent cognitive signals over Bonjour LAN or WebSocket relay. Implements the Mesh Memory Protocol (MMP) for structured cognitive state exchange between Claude Code sessions.",
+      "version": "0.2.0",
       "author": {
         "name": "Hongwei Xu",
         "email": "hongwei@sym.bot"

package/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "sym-mesh-channel",
-  "version": "0.1.23",
-  "description": "Real-time Claude-to-Claude mesh. Peer-to-peer cognitive signals over Bonjour LAN or WebSocket relay.",
+  "version": "0.2.0",
+  "description": "Real-time Claude-to-Claude mesh. Agent-to-agent cognitive signals over Bonjour LAN or WebSocket relay.",
   "author": {
     "name": "Hongwei Xu",
     "email": "hongwei@sym.bot",

package/CHANGELOG.md

@@ -1,5 +1,38 @@
 # Changelog
 
+## 0.2.0
+
+### Breaking
+
+- **`sym_send` tool signature change.** `sym_send` now emits a structured
+  CAT7 CMB (MMP §4.2) instead of a raw-text `type:'message'` frame, and
+  accepts an optional `to` parameter for targeted single-peer delivery
+  per MMP §4.4.4.
+
+  Old signature: `sym_send(message: string)`
+  New signature: `sym_send(focus: string (required), issue?, intent?,
+  motivation?, commitment?, perspective?, mood?, to?)`
+
+  Migration: agents that previously called `sym_send({message: "..."})`
+  should now pass the CAT7 fields explicitly, with `focus` carrying the
+  task anchor for the send. Prior ephemeral text-broadcast behaviour is
+  no longer exposed at the tool surface — `sym_send` and `sym_observe`
+  both emit CMBs now, receivers run SVAF per §9.2, and admitted CMBs are
+  remix-stored with lineage. The low-level `node.send(text)` SDK API is
+  unchanged but no longer surfaced as a tool.
+
+### Added
+
+- **Targeted CMB send.** `sym_send` resolves `to` against connected
+  peers by full nodeId first, then display name, then 8-char prefix.
+  Ambiguous matches return an error asking for the full nodeId; a
+  disconnected target returns an error and suggests `sym_peers`.
+- **Tool descriptions** for `sym_send` and `sym_observe` now explicitly
+  call out the SVAF receive path and lineage semantics, and the MCP
+  server's `instructions` string reflects the new division of labour.
+- **`@sym-bot/sym` dependency bumped to `^0.3.81`** for
+  `remember(fields, {to})` targeted variant and `peers().peerId`.
+
 ## 0.1.23
 
 ### Added

package/README.md

@@ -8,7 +8,7 @@
 
 > MCP server that turns Claude Code into a peer node on the [SYM mesh](https://sym.bot) — the first non-Anthropic implementation of Claude Code Channels for real-time agent-to-agent cognition.
 
-Two Claude Code sessions on different machines discover each other via Bonjour mDNS, form a peer-to-peer mesh, and exchange structured cognitive signals in real-time. Each side is a full peer with its own cryptographic identity, its own [SVAF](https://arxiv.org/abs/2604.03955) receiver-side gating, and its own memory — not a thin client. Signals arrive mid-conversation as `<channel>` notifications. No polling, no shared server, no orchestrator.
+Two Claude Code sessions on different machines discover each other via Bonjour mDNS, form a mesh, and exchange structured agent-to-agent cognitive signals in real-time. Each side is a full peer with its own cryptographic identity, its own [SVAF](https://arxiv.org/abs/2604.03955) receiver-side gating, and its own memory — not a thin client. Signals arrive mid-conversation as `<channel>` notifications. No polling, no shared server, no orchestrator.
 
 **Verified cross-platform:** Mac ↔ Windows on the same wifi, pure Bonjour, no relay, no token. Cross-network via optional WebSocket relay.
 
@@ -160,7 +160,7 @@ SYM-mesh groups visible on LAN (3):
   _frontend-team._tcp group="frontend-team"
 ```
 
-Only shows groups with at least one node online right now — there's no central directory of offline-but-known groups (peer-to-peer architecture). For cross-network relay-backed groups, you must know the relay URL + token out of band (someone shares the invite URL).
+Only shows groups with at least one node online right now — there's no central directory of offline-but-known groups (decentralised architecture). For cross-network relay-backed groups, you must know the relay URL + token out of band (someone shares the invite URL).
 
 ### Advanced: per-project node identity
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sym-bot/mesh-channel",
-  "version": "0.1.23",
+  "version": "0.2.0",
   "description": "MCP server — real-time agent-to-agent cognition for Claude Code remote teams via the SYM mesh.",
   "main": "server.js",
   "bin": {
@@ -22,7 +22,7 @@
   ],
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.12.1",
-    "@sym-bot/sym": "^0.3.78"
+    "@sym-bot/sym": "^0.3.81"
   },
   "engines": {
     "node": ">=18"

package/server.js

@@ -263,8 +263,9 @@ const mcp = new Server(
     instructions:
       `You are a peer node on the SYM mesh (identity: ${NODE_NAME}). ` +
       'Mesh events arrive as <channel> notifications in real-time. ' +
-      'When you see a message or CMB from another node, respond via the sym_send tool if actionable. ' +
-      'Share observations about the user\'s state via sym_observe. ' +
+      'When you see a CMB from another node, respond via sym_send targeted at that node by name if the reply is for that specific peer (MMP §4.4.4 targeted CMB). ' +
+      'Share observations about your own state with the whole mesh via sym_observe (MMP §9.2 receiver-autonomous SVAF evaluation). ' +
+      'Both sym_send and sym_observe emit CAT7 CMBs; receivers run SVAF and, if admitted, remix-store with lineage pointing back to your CMB. ' +
       'Search mesh memory via sym_recall. ' +
       'Messages arrive as compact headers with [mNNN] IDs — use sym_fetch to read the full content when the header is relevant to your current task.',
   },
@@ -276,16 +277,44 @@ mcp.setRequestHandler(ListToolsRequestSchema, async () => ({
   tools: [
     {
       name: 'sym_send',
-      description: 'Send a message to all mesh peers. Stored as a persistent CMB and broadcast via relay.',
+      description:
+        'Send a structured CAT7 CMB to a specific mesh peer (targeted) or to all peers (broadcast, when "to" is omitted). ' +
+        'Receivers evaluate the CMB per-field via SVAF (MMP §9.2) and, if admitted, remix-store it with lineage pointing back to this CMB. ' +
+        'Use sym_send when the CMB is for a specific peer (e.g. a peer-review gating request directed at the reviewer role); ' +
+        'use sym_observe when sharing your own state with the whole mesh.',
       inputSchema: {
         type: 'object',
-        properties: { message: { type: 'string', description: 'Message to broadcast' } },
-        required: ['message'],
+        properties: {
+          focus: { type: 'string', description: 'The task anchor / what this CMB is about. Required.' },
+          issue: { type: 'string' },
+          intent: { type: 'string' },
+          motivation: { type: 'string' },
+          commitment: { type: 'string' },
+          perspective: { type: 'string' },
+          mood: {
+            type: 'object',
+            properties: {
+              text: { type: 'string' },
+              valence: { type: 'number' },
+              arousal: { type: 'number' },
+            },
+          },
+          to: {
+            type: 'string',
+            description:
+              'Target peer: either the peer display name (e.g. "claude-research-win") or the full nodeId. ' +
+              'Call sym_peers first if unsure which peers are connected. Omit to broadcast to all peers.',
+          },
+        },
+        required: ['focus'],
       },
     },
     {
       name: 'sym_observe',
-      description: 'Share a structured CAT7 observation with the mesh. Extract fields from what you observe.',
+      description:
+        'Broadcast a structured CAT7 observation about your own state to all mesh peers. ' +
+        'Receivers run SVAF (MMP §9.2) and admitted CMBs are remix-stored with lineage. ' +
+        'Equivalent to sym_send with "to" omitted — kept as a separate tool because self-observation is the common case and does not need peer selection.',
       inputSchema: {
         type: 'object',
         properties: {
@@ -388,22 +417,60 @@ mcp.setRequestHandler(CallToolRequestSchema, async (request) => {
 
   switch (name) {
     case 'sym_send': {
-      // Direct inter-node message — broadcast as type:'message' frame only.
-      // Do NOT also persist as a CMB via node.remember(): that caused
-      // double-delivery on receivers, who saw the same payload arrive once
-      // as event_type='message' (from this broadcast) and again as
-      // event_type='cmb' (from CMB gossip replication). One tool, one job:
-      // sym_send is for ephemeral inter-node messages; sym_observe is for
-      // structured CAT7 CMBs. Hosts that want both should call both.
-      //
-      // Report the actual delivered count (the number of peer transports
-      // that successfully accepted the broadcast), not peers().length.
-      // The two can disagree when peers are in _peers but their transports
-      // are broken — counting peers().length would lie about delivery.
-      // Requires @sym-bot/sym >= 0.3.70 where send() returns the count.
-      const msg = args.message;
-      const delivered = node.send(msg);
-      return { content: [{ type: 'text', text: `Message delivered to ${delivered} peer(s).` }] };
+      // Emit a structured CAT7 CMB per MMP §4.2. When args.to names a peer,
+      // route as a targeted send (§4.4.4); otherwise broadcast. Receivers
+      // run SVAF (§9.2) and remix-store on accept — no separate "message"
+      // frame path, no raw-text channel.
+      const fields = {
+        focus: args.focus || 'directive',
+        issue: args.issue || 'none',
+        intent: args.intent || 'directive',
+        motivation: args.motivation || '',
+        commitment: args.commitment || '',
+        perspective: args.perspective || NODE_NAME,
+        mood: args.mood || { text: 'neutral', valence: 0, arousal: 0 },
+      };
+
+      let targetPeerId = null;
+      if (args.to) {
+        const peers = node.peers();
+        // Exact full-nodeId match first (unambiguous).
+        const byNodeId = peers.filter(p => p.peerId === args.to);
+        // Name match second.
+        const byName = peers.filter(p => p.name === args.to);
+        // Short-id prefix match last (for human-typed 8-char prefixes).
+        const byPrefix = peers.filter(p => p.id === args.to);
+
+        let matches;
+        if (byNodeId.length > 0) matches = byNodeId;
+        else if (byName.length > 0) matches = byName;
+        else if (byPrefix.length > 0) matches = byPrefix;
+        else matches = [];
+
+        if (matches.length === 0) {
+          return {
+            content: [{ type: 'text', text: `Peer "${args.to}" not connected. Call sym_peers to see connected peers.` }],
+            isError: true,
+          };
+        }
+        if (matches.length > 1) {
+          const names = matches.map(p => `${p.name} (${p.peerId})`).join(', ');
+          return {
+            content: [{ type: 'text', text: `Peer "${args.to}" is ambiguous — matches: ${names}. Pass the full nodeId.` }],
+            isError: true,
+          };
+        }
+        targetPeerId = matches[0].peerId;
+      }
+
+      const entry = node.remember(fields, targetPeerId ? { to: targetPeerId } : {});
+      if (!entry) {
+        return { content: [{ type: 'text', text: 'Duplicate — CMB already in memory, not re-broadcast.' }] };
+      }
+      const summary = targetPeerId
+        ? `Sent CMB ${entry.key} to ${args.to}`
+        : `Broadcast CMB ${entry.key} to all peers`;
+      return { content: [{ type: 'text', text: summary }] };
     }
 
     case 'sym_observe': {