@sym-bot/mesh-channel 0.3.22 → 0.3.25

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "sym-mesh-channel",
-  "version": "0.3.22",
+  "version": "0.3.25",
   "description": "Real-time Claude-to-Claude mesh. Agent-to-agent cognitive signals over Bonjour LAN or WebSocket relay.",
   "author": {
     "name": "Hongwei Xu",

package/.mcp.json

@@ -4,7 +4,7 @@
       "command": "npx",
       "args": [
         "-y",
-        "@sym-bot/mesh-channel@0.3.22"
+        "@sym-bot/mesh-channel@0.3.25"
       ],
       "env": {
         "SYM_RELAY_URL": "${user_config.relay_url}",

package/CHANGELOG.md

@@ -1,5 +1,23 @@
 # Changelog
 
+## 0.3.25
+
+### Changed
+
+- **Runs the `meshmem/` → `cmbs/` store migration on install** (`bin/install.js` calls `@sym-bot/sym`'s `migrateStores()`), so every non-live node is migrated when the plugin is set up. Pairs with `@sym-bot/sym` 0.7.16.
+
+## 0.3.24
+
+### Changed
+
+- **MCP tools renamed to canonical Enterprise Integration Pattern verbs:** `sym_observe` → **`sym_publish`** (Publish-Subscribe Channel) and `sym_inbox` → **`sym_receive`** (Polling Consumer). The I/O surface now reads as what the agent *does* (publish / send / receive), while the cognitive mechanism terms (emit/admit, projection/observation) stay in the MMP spec one layer down. `sym_send` (Point-to-Point) unchanged. Clean break — no aliases. Agent instructions + tool descriptions updated: publishing emits a *projection* of your state; a receiver that admits it takes it as an *observation*.
+
+## 0.3.23
+
+### Changed
+
+- **Removed the automatic `postinstall` registration.** The package no longer mutates `~/.claude.json` (or a project `.mcp.json`) on `npm install`. As a Claude Code **plugin**, the package is launched via `npx` on every session start, and the postinstall re-registered a competing user-scoped `claude-sym-mesh` MCP server each time — producing a second mesh node alongside the plugin's own. Registration now happens only via the explicit `start`/`init` commands, which the standalone flow (`npx @sym-bot/mesh-channel start`) already runs and which self-configure on first launch — so there is no change for standalone users, and the plugin path no longer double-registers. Pairs with the 0.3.22 `.sym/node.json` reader to make the plugin the single, stable, per-project mesh node.
+
 ## 0.3.22
 
 ### Added

package/README.md

@@ -106,8 +106,9 @@ Eleven MCP tools exposed to Claude Code, namespaced under `mcp__claude-sym-mesh_
 
 | Tool | What it does |
 |---|---|
-| `sym_send` | Broadcast a free-text message to all mesh peers. Arrives in receivers' contexts as a `<channel>` notification. |
-| `sym_observe` | Share a structured CAT7 observation: focus, issue, intent, motivation, commitment, perspective, mood. SVAF-gated on the receiving side. |
+| `sym_send` | Send a CAT7 CMB to a specific peer (point-to-point), or to all if no recipient is given. Arrives in receivers' contexts as a `<channel>` notification. |
+| `sym_publish` | Publish a structured CAT7 CMB — a projection of your state — to your whole group (publish-subscribe): focus, issue, intent, motivation, commitment, perspective, mood. SVAF-gated on the receiving side. |
+| `sym_receive` | Surface CMBs the mesh delivered to you in real-time when the `<channel>` push was gated — a live delivery feed, not a store query. |
 | `sym_recall` | Search mesh memory for past cognitive memory blocks. |
 | `sym_fetch` | Fetch the full content of a single CMB by its compact channel-header ID. |
 | `sym_peers` | List discovered peers (via bonjour or relay). |
@@ -230,7 +231,7 @@ The plugin composes two open specs:
 - **[Claude Code Channels](https://code.claude.com/docs/en/mcp)** (Anthropic, 2026-03-20) — an MCP capability that lets servers push events directly into Claude's conversation context mid-turn via `notifications/claude/channel`. Anthropic built it for the Telegram/Discord/iMessage integrations. We use it for agent-to-agent cognitive coupling.
 - **[MMP — the Mesh Memory Protocol](https://meshcognition.org/spec/mmp)** — defines *what* gets pushed: typed seven-field cognitive bundles (CAT7: focus, issue, intent, motivation, commitment, perspective, mood), how receivers gate incoming signals ([SVAF](https://arxiv.org/abs/2604.03955)), and how peers maintain identity without a central orchestrator.
 
-**What happens on each message.** When a peer broadcasts a cognitive memory block (CMB), the local SymNode evaluates it via SVAF — Symbolic-Vector Attention Fusion, a receiver-side relevance gate that rejects low-signal messages before they reach Claude's context. If accepted, the MCP server fires a `notifications/claude/channel` notification to Claude Code, which surfaces it as a `<channel>` block in the conversation. Claude sees it, can react, and can broadcast back via `sym_send` or `sym_observe`. No polling. No tool calls. The mesh thinks together.
+**What happens on each message.** When a peer broadcasts a cognitive memory block (CMB), the local SymNode evaluates it via SVAF — Symbolic-Vector Attention Fusion, a receiver-side relevance gate that rejects low-signal messages before they reach Claude's context. If accepted, the MCP server fires a `notifications/claude/channel` notification to Claude Code, which surfaces it as a `<channel>` block in the conversation. Claude sees it, can react, and can broadcast back via `sym_send` or `sym_publish`. No polling. No tool calls. The mesh thinks together.
 
 **Identity and transport.** Each peer has its own Ed25519 keypair stored at `~/.sym/nodes/<name>/identity.json`. Node IDs are UUID v7 + Ed25519 signatures, gossiped through the relay's directory or via Bonjour TXT records. Full architecture in MMP §4–§6.
 

package/bin/install.js

@@ -60,6 +60,13 @@ if (cmd !== 'init' && cmd !== 'doctor' && cmd !== 'start') {
   process.exit(1);
 }
 
+// One-time bulk store migration (meshmem/ → cmbs/) for all non-live nodes, run
+// on install so readers use the cmbs/ name with no fallback. Idempotent.
+try {
+  const n = require('@sym-bot/sym').migrateStores();
+  if (n) process.stderr.write(`[sym-mesh-channel] migrated ${n} node store(s): meshmem → cmbs\n`);
+} catch { /* SDK not resolvable or nothing to do — non-fatal */ }
+
 const KEBAB_CASE_RE = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
 function validateGroupValue(value, source) {
   if (!value) return;

package/package.json

@@ -1,14 +1,13 @@
 {
   "name": "@sym-bot/mesh-channel",
-  "version": "0.3.22",
+  "version": "0.3.25",
   "description": "MCP server — real-time agent-to-agent cognition for Claude Code remote teams via the SYM mesh.",
   "main": "server.js",
   "bin": {
     "sym-mesh-channel": "server.js"
   },
   "scripts": {
-    "test": "node test/plugin.test.js",
-    "postinstall": "node bin/install.js init --postinstall"
+    "test": "node test/plugin.test.js"
   },
   "files": [
     "server.js",
@@ -22,7 +21,7 @@
   ],
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.12.1",
-    "@sym-bot/sym": "^0.7.11",
+    "@sym-bot/sym": "^0.7.16",
     "bonjour-service": "^1.3.0"
   },
   "engines": {

package/server.js

@@ -34,7 +34,7 @@ process.stdout.write = function (chunk, ...rest) {
  * Architecture (MMP Section 13.9: Local Event Interface):
  *   SymNode (own identity, own SVAF field weights) → relay → mesh
  *   MCP channel notifications → Claude Code (real-time push)
- *   MCP tools → SymNode methods (send, observe, recall)
+ *   MCP tools → SymNode methods (send, publish, recall)
  *
  * This is a PEER NODE, not a client of the daemon. It has its own identity,
  * its own relay connection, and its own SVAF evaluation with engineering-domain
@@ -360,12 +360,12 @@ function registerNodeHandlers(n) {
 // 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 may arrive as <channel> notifications in real-time, but that push can be gated by Claude Code policy — so to RECEIVE reliably, call sym_inbox to PULL messages addressed to you (directed sym_send + admitted broadcasts). Call sym_inbox at the start of your turn and periodically while coordinating with peers, so you never miss one. ' +
+  'The mesh is publish-subscribe: peers deliver CMBs to you in real-time the instant they publish, as <channel> notifications. That real-time push can be gated by Claude Code policy, so call sym_receive to surface any deliveries the push did not bring into your context (directed sym_send + admitted broadcasts) — a live delivery feed, not a memory query. Call sym_receive at the start of your turn and periodically while coordinating with peers, so no delivery is missed. ' +
   'When you receive 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. ' +
+  'Publish a CMB to your whole group via sym_publish — a projection of your own state (MMP §9.2 receiver-autonomous SVAF evaluation). ' +
+  'Both sym_send and sym_publish emit a CAT7 CMB (your projection); each receiver runs SVAF and, if it admits the CMB as an observation, remix-stores it with lineage back to yours. ' +
   'Search mesh memory via sym_recall. ' +
-  'sym_inbox and <channel> notifications give compact headers with [mNNN] IDs — use sym_fetch to read the full content when relevant to your current task.';
+  'sym_receive and <channel> notifications give compact headers with [mNNN] IDs — use sym_fetch to read the full content when 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
@@ -407,7 +407,7 @@ mcp.setRequestHandler(ListToolsRequestSchema, async () => ({
         '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.',
+        'use sym_publish when publishing your own state to the whole group.',
       inputSchema: {
         type: 'object',
         properties: {
@@ -444,11 +444,11 @@ mcp.setRequestHandler(ListToolsRequestSchema, async () => ({
       },
     },
     {
-      name: 'sym_observe',
+      name: 'sym_publish',
       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.',
+        'Publish a structured CAT7 CMB — a projection of your own state — to all peers in your group. ' +
+        'Each receiver runs SVAF (MMP §9.2) and, if it admits the CMB as an observation, remix-stores it with lineage. ' +
+        'Equivalent to sym_send with "to" omitted — kept as a separate tool because publishing your own state is the common case and does not need peer selection.',
       inputSchema: {
         type: 'object',
         properties: {
@@ -505,8 +505,8 @@ mcp.setRequestHandler(ListToolsRequestSchema, async () => ({
       },
     },
     {
-      name: 'sym_inbox',
-      description: 'PULL mesh messages received since your last inbox check — directed sym_send addressed to you, plus admitted broadcasts. This is the poll-based RECEIVE path: real-time channel push can be gated by Claude Code policy, but this tool always works. Call it at the start of a turn and periodically while coordinating so you never miss a peer. Returns compact headers with [mNNN] IDs (newest last); use sym_fetch for full content, reply via sym_send.',
+      name: 'sym_receive',
+      description: 'Surface the CMBs the mesh has delivered to you in real-time — directed sym_send addressed to you, plus admitted broadcasts published to your group. The mesh is publish-subscribe: peers deliver the instant they publish, pushed as <channel> notifications. Because that push can be gated by Claude Code policy, sym_receive surfaces any deliveries it missed so none is lost — a live delivery feed, NOT a store query (use sym_recall to search stored memory). Call it at the start of a turn and periodically while coordinating so no delivery is missed. Returns compact headers with [mNNN] IDs (newest last); use sym_fetch for full content, reply via sym_send.',
       inputSchema: {
         type: 'object',
         properties: {
@@ -627,7 +627,7 @@ mcp.setRequestHandler(CallToolRequestSchema, async (request) => {
       return { content: [{ type: 'text', text: summary }] };
     }
 
-    case 'sym_observe': {
+    case 'sym_publish': {
       const fields = {
         focus: args.focus || 'observation',
         issue: args.issue || 'none',
@@ -640,7 +640,7 @@ mcp.setRequestHandler(CallToolRequestSchema, async (request) => {
       const observeOpts = {};
       if (args.payload !== undefined && args.payload !== null) observeOpts.payload = args.payload;
       const entry = node.remember(fields, observeOpts);
-      return { content: [{ type: 'text', text: entry ? `Observed: ${entry.key}` : 'Duplicate — already in memory.' }] };
+      return { content: [{ type: 'text', text: entry ? `Published: ${entry.key}` : 'Duplicate — already in memory.' }] };
     }
 
     case 'sym_recall': {
@@ -685,12 +685,12 @@ mcp.setRequestHandler(CallToolRequestSchema, async (request) => {
       };
     }
 
-    case 'sym_inbox': {
+    case 'sym_receive': {
       // Thin adapter over the SDK primitive: the node owns the delivery buffer
       // + drain cursor (node.inbox()). This wrapper only formats for display.
       const { messages, remaining } = node.inbox({ peek: !!args.peek, limit: args.limit });
       if (!messages.length) {
-        return { content: [{ type: 'text', text: 'Inbox empty — no new mesh messages since your last check.' }] };
+        return { content: [{ type: 'text', text: 'Caught up — nothing new delivered since your last sym_receive.' }] };
       }
       const now = Date.now();
       const lines = messages.map((m) => {
@@ -707,9 +707,9 @@ mcp.setRequestHandler(CallToolRequestSchema, async (request) => {
         return `[${m.from}${dirTag}] ${String(focus).replace(/\s+/g, ' ').slice(0, 90)}${memTag} [${m.id}] (${age}s ago)`;
       }).filter(Boolean);
       if (!lines.length) {
-        return { content: [{ type: 'text', text: 'Inbox empty — no new mesh messages since your last check.' }] };
+        return { content: [{ type: 'text', text: 'Caught up — nothing new delivered since your last sym_receive.' }] };
       }
-      const moreNote = remaining > 0 ? ` (+${remaining} more — call sym_inbox again)` : '';
+      const moreNote = remaining > 0 ? ` (+${remaining} more — call sym_receive again)` : '';
       return {
         content: [{
           type: 'text',