@sym-bot/mesh-channel 0.1.5 → 0.1.6

package/CHANGELOG.md

@@ -1,5 +1,31 @@
 # Changelog
 
+## 0.1.6
+
+### Fixed
+
+- `sym_send` no longer double-delivers. Previously called both
+  `node.send()` (broadcast as `event_type=message`) AND `node.remember()`
+  (persist as CMB which gets gossiped as `event_type=cmb`), causing
+  the same payload to arrive twice on receivers and double the
+  context-window cost. Now broadcasts the message frame only. Hosts
+  that want CMB persistence should call `sym_observe` separately
+  with proper CAT7 fields.
+- `sym_send` now reports the actual delivered count, not
+  `peers().length`. Requires `@sym-bot/sym >= 0.3.70` where `send()`
+  returns the count of peer transports that successfully accepted
+  the broadcast. The two can disagree when peers are tracked but
+  have broken transports — the delivered count is the truth about
+  what was actually sent.
+
+### Changed
+
+- Bumped `@sym-bot/sym` dep `^0.3.69` → `^0.3.70`. 0.3.70 ships the
+  identity lockfile that prevents two SymNode processes from
+  claiming the same nodeId on a host (the cliHostMode-vs-MCP
+  collision that broke real-time push on Windows during the
+  2026-04-09 round-trip test).
+
 ## 0.1.5
 
 ### Changed

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sym-bot/mesh-channel",
-  "version": "0.1.5",
+  "version": "0.1.6",
   "description": "MCP server — Claude Code as a peer node on the SYM mesh",
   "main": "server.js",
   "bin": {
@@ -13,7 +13,7 @@
     "LICENSE"
   ],
   "dependencies": {
-    "@sym-bot/sym": "^0.3.69",
+    "@sym-bot/sym": "^0.3.70",
     "@modelcontextprotocol/sdk": "^1.12.1"
   },
   "engines": {

package/server.js

@@ -145,19 +145,22 @@ 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;
-      node.send(msg);
-      node.remember({
-        focus: msg,
-        issue: 'none',
-        intent: 'inter-node message',
-        motivation: 'mesh communication',
-        commitment: msg.slice(0, 120),
-        perspective: `${NODE_NAME}, direct message`,
-        mood: { text: 'neutral', valence: 0, arousal: 0 },
-      });
-      const peers = node.peers();
-      return { content: [{ type: 'text', text: `Message sent to ${peers.length} peer(s).` }] };
+      const delivered = node.send(msg);
+      return { content: [{ type: 'text', text: `Message delivered to ${delivered} peer(s).` }] };
     }
 
     case 'sym_observe': {