@sym-bot/mesh-channel 0.3.20 → 0.3.22

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "sym-mesh-channel",
-  "version": "0.3.20",
+  "version": "0.3.22",
   "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.20"
+        "@sym-bot/mesh-channel@0.3.22"
       ],
       "env": {
         "SYM_RELAY_URL": "${user_config.relay_url}",

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # Changelog
 
+## 0.3.22
+
+### Added
+
+- **Per-project identity via `$CLAUDE_PROJECT_DIR/.sym/node.json`.** A named role agent (e.g. a CTO node `claude-code-mac` on `sym-bot-team`, or `melotune-dev` on `melo-ios`) can now commit `{ "node_name": "...", "group": "..." }` to `.sym/node.json` in its repo, and the plugin reads it on start. This lets the **plugin alone** carry a stable, per-project identity — no parallel `claude-sym-mesh` MCP registration in a project `.mcp.json`, which previously produced a *second* mesh node (the project-scoped server plus the plugin-scoped server are never deduplicated). Because the identity lives in the repo, it survives a plugin reinstall. Precedence is unchanged-and-extended: `SYM_NODE_NAME`/`SYM_GROUP` env still win, then `.sym/node.json`, then the auto `claude-<repo>-<session>` default. A missing or malformed file is ignored (falls back to the auto default) — never a hard fail.
+
+## 0.3.21
+
+### Changed
+
+- **`sym_inbox` is now a thin adapter over the SDK primitive `node.inbox()`** (`@sym-bot/sym` ^0.7.11). The pull-based receive buffer + drain cursor moved down into the node, where it belongs alongside `node.remember()` (send) — so the SDK is sufficient for send **and** pull on its own, and the wrapper owns no buffering logic. Behaviour is unchanged (FIFO drain, `peek`, `limit`); `sym_fetch` now also resolves SDK inbox ids (`inNNNN`). The wrapper still applies the peer allowlist + prompt-injection filter on the pull path before anything enters context.
+
 ## 0.3.20
 
 ### Added

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sym-bot/mesh-channel",
-  "version": "0.3.20",
+  "version": "0.3.22",
   "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.7.10",
+    "@sym-bot/sym": "^0.7.11",
     "bonjour-service": "^1.3.0"
   },
   "engines": {

package/server.js

@@ -232,7 +232,23 @@ function resolveNodeName(base) {
   }
   return base;
 }
-const NODE_NAME = resolveNodeName(process.env.SYM_NODE_NAME || defaultNodeName());
+// Per-project identity (v0.3.22): a named role agent (CTO, melotune-dev, …) commits
+// its node name + group to `$CLAUDE_PROJECT_DIR/.sym/node.json`, so the plugin alone
+// carries a stable per-project identity — no parallel MCP registration, and it
+// survives a plugin reinstall because the config lives in the repo, not the plugin.
+// Env (SYM_NODE_NAME/SYM_GROUP) still wins; this only overrides the auto default.
+// Missing/malformed file → {} → auto default; never a hard fail.
+function projectNodeConfig() {
+  const fs = require('fs'), path = require('path');
+  const dir = process.env.CLAUDE_PROJECT_DIR || process.cwd();
+  try {
+    const cfg = JSON.parse(fs.readFileSync(path.join(dir, '.sym', 'node.json'), 'utf8'));
+    const clean = (s) => (typeof s === 'string' && s.trim()) ? s.trim() : undefined;
+    return { node_name: clean(cfg.node_name), group: clean(cfg.group) };
+  } catch { return {}; }
+}
+const PROJECT_CFG = projectNodeConfig();
+const NODE_NAME = resolveNodeName(process.env.SYM_NODE_NAME || PROJECT_CFG.node_name || defaultNodeName());
 
 // ── Mesh group (MMP §5.8) ──────────────────────────────────
 //
@@ -245,7 +261,7 @@ const NODE_NAME = resolveNodeName(process.env.SYM_NODE_NAME || defaultNodeName()
 function resolveServiceType() {
   const explicit = process.env.SYM_SERVICE_TYPE;
   if (explicit) return explicit;
-  const group = process.env.SYM_GROUP;
+  const group = process.env.SYM_GROUP || PROJECT_CFG.group;
   if (group && group !== 'default') return `_${group}._tcp`;
   return '_sym._tcp';
 }
@@ -253,7 +269,7 @@ function resolveServiceType() {
 // Claude Code restart. Declaring as `let` rather than `const` is the
 // smallest change that makes hot-swap possible.
 let SERVICE_TYPE = resolveServiceType();
-let GROUP = process.env.SYM_GROUP || (SERVICE_TYPE !== '_sym._tcp'
+let GROUP = process.env.SYM_GROUP || PROJECT_CFG.group || (SERVICE_TYPE !== '_sym._tcp'
   ? SERVICE_TYPE.replace(/^_/, '').replace(/\._tcp$/, '')
   : 'default');
 let RELAY_URL = process.env.SYM_RELAY_URL || null;
@@ -651,6 +667,12 @@ mcp.setRequestHandler(CallToolRequestSchema, async (request) => {
     }
 
     case 'sym_fetch': {
+      // inNNNN → SDK delivery inbox (pull path); mNNN → channel-push store.
+      if (typeof args.msg_id === 'string' && args.msg_id.startsWith('in')) {
+        const m = node.inboxGet(args.msg_id);
+        if (!m) return { content: [{ type: 'text', text: `Message ${args.msg_id} not found (expired or invalid ID).` }] };
+        return { content: [{ type: 'text', text: `[${m.from}] ${new Date(m.receivedAt).toISOString()}\n\n${m.content}` }] };
+      }
       const entry = MESSAGE_STORE.get(args.msg_id);
       if (!entry) {
         return { content: [{ type: 'text', text: `Message ${args.msg_id} not found (expired or invalid ID).` }] };
@@ -664,35 +686,34 @@ mcp.setRequestHandler(CallToolRequestSchema, async (request) => {
     }
 
     case 'sym_inbox': {
-      const limit = Math.max(1, Math.min(args.limit || 50, MAX_STORED));
-      const fresh = [];
-      for (const [id, entry] of MESSAGE_STORE) {
-        const seq = parseInt(id.slice(1), 10);
-        if (seq > inboxCursor) fresh.push({ id, seq, entry });
-      }
-      fresh.sort((a, b) => a.seq - b.seq);
-      // FIFO: drain the OLDEST `limit` first so the cursor advances contiguously
-      // and a backlog larger than `limit` is never skipped — the rest come on the
-      // next call. (Newest-first would jump the cursor past un-returned items.)
-      const slice = fresh.slice(0, limit);
-      if (!args.peek && slice.length) {
-        inboxCursor = Math.max(inboxCursor, ...slice.map((i) => i.seq));
-      }
-      if (!slice.length) {
+      // 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.' }] };
       }
-      const more = fresh.length - slice.length;
       const now = Date.now();
-      const lines = slice.map(({ id, entry }) => {
-        const age = Math.round((now - entry.timestamp) / 1000);
-        const head = entry.header || `[${entry.from}] ${String(entry.content || '').replace(/\s+/g, ' ').slice(0, 80)}`;
-        return `${head} [${id}] (${age}s ago)`;
-      });
-      const moreNote = more > 0 ? ` (+${more} more — call sym_inbox again)` : '';
+      const lines = messages.map((m) => {
+        if (m.from === NODE_NAME) return null; // never surface our own deliveries
+        // The security layer still gates the pull path: peer allowlist +
+        // prompt-injection filter run on every message before it enters context.
+        if (!isPeerAllowed(m.from)) return null;
+        const sec = checkSecurity(m.from, m.fields || {}, m.fields?.payload);
+        if (!sec.safe) { securityAudit(sec.reason, m.from, sec.excerpt); return null; }
+        const age = Math.round((now - m.receivedAt) / 1000);
+        const focus = m.fields?.focus?.text || m.content || '';
+        const dirTag = m.directed ? ' →you' : '';
+        const memTag = m.directed && m.remixed === false ? ' ·not-stored' : '';
+        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.' }] };
+      }
+      const moreNote = remaining > 0 ? ` (+${remaining} more — call sym_inbox again)` : '';
       return {
         content: [{
           type: 'text',
-          text: `${slice.length} new mesh message(s)${args.peek ? ' (peek — not drained)' : ''}${moreNote}:\n${lines.join('\n')}\n\nUse sym_fetch <id> for full content; reply via sym_send to=<peer>.`,
+          text: `${lines.length} new mesh message(s)${args.peek ? ' (peek — not drained)' : ''}${moreNote}:\n${lines.join('\n')}\n\nUse sym_fetch <id> for full content; reply via sym_send to=<peer>.`,
         }],
       };
     }
@@ -909,9 +930,8 @@ mcp.setRequestHandler(CallToolRequestSchema, async (request) => {
 // Per COO spec cmb_compact_channel_v0.1.md: push compact headers,
 // store full content for on-demand sym_fetch retrieval. ~10% token
 // savings on mesh traffic without context loss.
-const MESSAGE_STORE = new Map();
+const MESSAGE_STORE = new Map(); // channel-push surface (mNNN) for sym_fetch when channels are enabled
 let msgSeq = 0;
-let inboxCursor = 0; // highest msgSeq drained by sym_inbox (pull-based receive)
 const MAX_STORED = 200;
 
 function storeMessage(from, content, header) {