@sym-bot/mesh-channel 0.1.23 → 0.3.0

package/.claude-plugin/marketplace.json

@@ -1,19 +1,19 @@
 {
   "name": "sym-mesh-channel",
   "owner": {
-    "name": "SYM.BOT Ltd",
+    "name": "SYM.BOT",
     "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,66 @@
 # Changelog
 
+## 0.3.0
+
+### Added
+
+- **Startup remix-memory primer — automates agent memory recall on
+  session/agent restart (MMP §4.2 O2, rejoin-without-replay).** As the
+  final step of plugin initialisation (after `node.start()` and before
+  the MCP transport connects), the plugin calls
+  `node.buildStartupPrimer()` and appends the returned text to the MCP
+  server's `instructions` field. A fresh Claude Code session wakes
+  with the agent's own remix memory — own observations plus peer
+  observations admitted by SVAF — already loaded into context. No
+  first-turn `sym_recall` required; agent acts from prior state
+  immediately.
+
+  Default caps: last 24 hours OR 20 most recent CMBs, whichever is
+  tighter. The primer lists each entry as `[timestamp] source · key —
+  focus` and surfaces a dropped-count line when caps elide older
+  entries. Empty store is a silent no-op.
+
+### Changed
+
+- **`@sym-bot/sym` dep bumped to `^0.5.0`** to pick up the
+  `buildStartupPrimer` helper and to keep every plugin on the
+  sym.day platform pinned to the same substrate SDK version
+  (no drift across mesh-channel / melotune-plugin / future
+  specialised plugins).
+
+## 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/LICENSE

@@ -186,7 +186,7 @@
       same "printed page" as the copyright notice for easier
       identification within third-party archives.
 
-   Copyright 2026 SYM.BOT Ltd
+   Copyright 2026 SYM.BOT
 
    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.

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
 
@@ -291,4 +291,4 @@ See [SECURITY.md](SECURITY.md) for the full security model.
 
 ## License
 
-Apache 2.0 — SYM.BOT Ltd
+Apache 2.0 — SYM.BOT

package/bin/install.js

@@ -24,7 +24,7 @@
  *   - Refuses to overwrite an existing claude-sym-mesh entry without
  *     --force.
  *
- * Copyright (c) 2026 SYM.BOT Ltd. Apache 2.0 License.
+ * Copyright (c) 2026 SYM.BOT. Apache 2.0 License.
  */
 
 const fs = require('fs');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sym-bot/mesh-channel",
-  "version": "0.1.23",
+  "version": "0.3.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.5.0"
   },
   "engines": {
     "node": ">=18"

package/server.js

@@ -19,7 +19,7 @@ if (process.argv[2] === 'init') {
  * its own relay connection, and its own SVAF evaluation with engineering-domain
  * field weights. Per MMP Section 3: every participant is a peer.
  *
- * Copyright (c) 2026 SYM.BOT Ltd. Apache 2.0 License.
+ * Copyright (c) 2026 SYM.BOT. Apache 2.0 License.
  */
 
 const { Server } = require('@modelcontextprotocol/sdk/server/index.js');
@@ -253,6 +253,35 @@ function registerNodeHandlers(n) {
 
 // ── MCP Server ───────────────────────────────────────────────
 
+// Base instructions shown to the agent at every MCP initialize.
+const BASE_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 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.';
+
+// Final startup step (MMP §4.2 O2 — rejoin-without-replay). The SymNode
+// constructor builds the memory-store index from disk, so the primer is
+// available synchronously without needing node.start(). Appending it to
+// the MCP instructions payload means a fresh Claude Code session wakes
+// with prior remix memory — own observations plus peer observations
+// admitted by SVAF — already loaded into context, zero first-turn
+// sym_recall overhead.
+//
+// MCP SDK reads `instructions` at Server construction time (storing it in
+// a private field) and emits it only on initialize-response; mutations on
+// the public property after construction are ignored. Compute once, pass in.
+let primerText = '';
+try {
+  const primer = node.buildStartupPrimer();
+  if (primer && primer.count > 0) primerText = `\n\n${primer.text}`;
+} catch (err) {
+  process.stderr.write(`sym-mesh-channel startup primer skipped: ${err?.message || err}\n`);
+}
+
 const mcp = new Server(
   { name: 'sym-mesh', version: '0.1.0' },
   {
@@ -260,13 +289,7 @@ const mcp = new Server(
       tools: {},
       experimental: { 'claude/channel': {} },
     },
-    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. ' +
-      '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.',
+    instructions: BASE_INSTRUCTIONS + primerText,
   },
 );
 
@@ -276,16 +299,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 +439,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': {
@@ -773,7 +862,9 @@ process.on('SIGINT',  () => shutdown('SIGINT'));
 process.on('SIGHUP',  () => shutdown('SIGHUP'));
 
 async function main() {
-  // Start SymNode — connects to relay as a peer
+  // Start SymNode — connects to relay as a peer. The startup primer is
+  // computed at module-load time (see BASE_INSTRUCTIONS above) and is
+  // already embedded in the MCP server's initialize-response payload.
   await node.start();
 
   // Start MCP server — communicates with Claude Code via stdio