@sym-bot/sym 0.2.1 → 0.2.2

package/bin/setup-claude.sh

@@ -1,30 +1,83 @@
 #!/bin/bash
 # SYM — Setup for Claude Code
-# Adds MCP server + auto-approves sym_mood + installs CLAUDE.md instructions
-# Optionally configures WebSocket relay for internet-scale mesh
+#
+# Installs:
+#   1. sym-daemon (persistent physical mesh node, launchd LaunchAgent)
+#   2. MCP server for Claude Code (virtual node, connects to daemon via IPC)
+#   3. Auto-approves sym_mood tool
+#   4. CLAUDE.md instructions for autonomous mood detection
+#
+# Usage:
+#   npx @sym-bot/sym setup        # or
+#   ./bin/setup-claude.sh [project-dir]
 
 set -e
 
 SYM_DIR="$(cd "$(dirname "$0")/.." && pwd)"
 MCP_SERVER="$SYM_DIR/integrations/claude-code/mcp-server.js"
+DAEMON_SCRIPT="$SYM_DIR/bin/sym-daemon.js"
 
-echo "SYM Setup for Claude Code"
-echo "========================="
+echo ""
+echo "  SYM Setup for Claude Code"
+echo "  ========================="
+echo ""
+
+# ── Step 1: Configure relay ─────────────────────────────────
+
+RELAY_ENV="$HOME/.sym/relay.env"
+mkdir -p "$HOME/.sym"
+
+if [ -f "$RELAY_ENV" ]; then
+  echo "  ✓ Relay config found: $RELAY_ENV"
+else
+  echo "  WebSocket Relay (connects your mesh across the internet)"
+  echo ""
+  read -p "  Relay URL (e.g. wss://sym-relay.onrender.com, or empty to skip): " RELAY_URL
+  if [ -n "$RELAY_URL" ]; then
+    read -p "  Relay token (or empty for open access): " RELAY_TOKEN
+    echo "SYM_RELAY_URL=$RELAY_URL" > "$RELAY_ENV"
+    if [ -n "$RELAY_TOKEN" ]; then
+      echo "SYM_RELAY_TOKEN=$RELAY_TOKEN" >> "$RELAY_ENV"
+    fi
+    echo "  ✓ Relay config saved: $RELAY_ENV"
+  else
+    echo "  → Skipping relay — using Bonjour (local network) only"
+  fi
+fi
+
+# ── Step 2: Install sym-daemon ──────────────────────────────
+
+echo ""
+echo "  Installing sym-daemon (persistent mesh node)..."
 
-# 1. Add MCP server
-echo "Adding SYM MCP server..."
+if [ "$(uname)" = "Darwin" ]; then
+  # macOS: install as launchd LaunchAgent
+  node "$DAEMON_SCRIPT" --install
+  echo "  ✓ sym-daemon installed as launchd LaunchAgent"
+  echo "    Auto-starts on login, auto-restarts on crash"
+  echo "    Logs: ~/Library/Logs/sym-daemon/"
+else
+  echo "  → macOS not detected. Start the daemon manually:"
+  echo "    node $DAEMON_SCRIPT"
+  echo "    (On Linux, create a systemd service)"
+fi
+
+# ── Step 3: Add MCP server ──────────────────────────────────
+
+echo ""
+echo "  Adding SYM MCP server to Claude Code..."
 claude mcp add --transport stdio sym --scope user -- node "$MCP_SERVER"
+echo "  ✓ MCP server registered"
 
-# 2. Auto-approve sym_mood (no permission prompt)
-echo "Auto-approving sym_mood tool..."
+# ── Step 4: Auto-approve sym_mood ───────────────────────────
+
+echo ""
+echo "  Auto-approving sym_mood tool..."
 CLAUDE_JSON="$HOME/.claude.json"
 if [ -f "$CLAUDE_JSON" ]; then
-  # Use node to safely modify JSON
   node -e "
     const fs = require('fs');
     const config = JSON.parse(fs.readFileSync('$CLAUDE_JSON', 'utf8'));
-
-    // Find all project entries and add sym_mood to allowedTools
     if (config.projects) {
       for (const [path, project] of Object.entries(config.projects)) {
         if (!project.allowedTools) project.allowedTools = [];
@@ -33,53 +86,36 @@ if [ -f "$CLAUDE_JSON" ]; then
         }
       }
     }
-
     fs.writeFileSync('$CLAUDE_JSON', JSON.stringify(config, null, 2));
-    console.log('  sym_mood auto-approved for all projects');
   "
-fi
-
-# 3. Configure relay (optional)
-echo ""
-echo "WebSocket Relay (optional)"
-echo "Connects your mesh across the internet — not just local network."
-echo ""
-
-SHELL_RC="$HOME/.zshrc"
-[ -f "$HOME/.bashrc" ] && [ ! -f "$HOME/.zshrc" ] && SHELL_RC="$HOME/.bashrc"
-
-if grep -q "SYM_RELAY_URL" "$SHELL_RC" 2>/dev/null; then
-  echo "  Relay already configured in $SHELL_RC"
+  echo "  ✓ sym_mood auto-approved"
 else
-  read -p "Relay URL (leave empty to skip): " RELAY_URL
-  if [ -n "$RELAY_URL" ]; then
-    read -p "Relay token (leave empty for open access): " RELAY_TOKEN
-    echo "" >> "$SHELL_RC"
-    echo "# SYM Mesh" >> "$SHELL_RC"
-    echo "export SYM_RELAY_URL=\"$RELAY_URL\"" >> "$SHELL_RC"
-    if [ -n "$RELAY_TOKEN" ]; then
-      echo "export SYM_RELAY_TOKEN=\"$RELAY_TOKEN\"" >> "$SHELL_RC"
-    fi
-    echo "  Relay configured in $SHELL_RC"
-    echo "  Run 'source $SHELL_RC' or restart your terminal to activate."
-  else
-    echo "  Skipping relay — using Bonjour (local network) only."
-  fi
+  echo "  → No .claude.json found — approve sym_mood manually when prompted"
 fi
 
-# 4. Append CLAUDE.md instructions if not already present
+# ── Step 5: Install CLAUDE.md ───────────────────────────────
+
 echo ""
-echo "Installing CLAUDE.md instructions..."
 PROJECT_DIR="${1:-$(pwd)}"
 CLAUDE_MD="$PROJECT_DIR/CLAUDE.md"
 
 if [ -f "$CLAUDE_MD" ] && grep -q "SYM Mesh Agent" "$CLAUDE_MD"; then
-  echo "  CLAUDE.md already has SYM instructions"
+  echo "  ✓ CLAUDE.md already has SYM instructions"
 else
   cat "$SYM_DIR/CLAUDE.md" >> "$CLAUDE_MD"
-  echo "  Added SYM instructions to $CLAUDE_MD"
+  echo "  ✓ Added SYM instructions to $CLAUDE_MD"
 fi
 
+# ── Done ────────────────────────────────────────────────────
+
+echo ""
+echo "  ──────────────────────────────────────"
+echo "  SYM is ready."
+echo ""
+echo "  • sym-daemon: running (check: node $DAEMON_SCRIPT --status)"
+echo "  • MCP server: registered (restart Claude Code to activate)"
+echo "  • Protocol spec: https://sym.bot/protocol"
+echo ""
+echo "  Say 'I'm exhausted' in Claude Code —"
+echo "  MeloTune will start playing calming music."
 echo ""
-echo "Done. Restart Claude Code to activate SYM."
-echo "Say 'I'm exhausted' — MeloTune will start playing."

package/bin/sym-daemon.js

@@ -42,7 +42,9 @@ const { SymNode } = require('../lib/node');
 // ── Configuration ──────────────────────────────────────────────
 
 const SOCKET_PATH = process.env.SYM_SOCKET || '/tmp/sym.sock';
-const NODE_NAME = process.env.SYM_NODE_NAME || os.hostname().split('.')[0].toLowerCase();
+// Stable name: use SYM_NODE_NAME env, or 'sym-daemon' (not hostname — macOS
+// appends random suffixes to hostname on WiFi, causing new identity each restart)
+const NODE_NAME = process.env.SYM_NODE_NAME || 'sym-daemon';
 const LOG_DIR = path.join(os.homedir(), 'Library', 'Logs', 'sym-daemon');
 
 // Load relay config from ~/.sym/relay.env if env vars not set
@@ -239,6 +241,24 @@ function forwardEventsToVirtualNodes() {
 
   node.on('message', (from, content) => {
     broadcastToVirtualNodes({ type: 'event', event: 'message', data: { from, content } });
+
+    // Wake sleeping peers that might need this message.
+    // The daemon acts as wake proxy — it has APNs keys and gossiped wake channels.
+    // When a remote peer (Telegram bot) sends a message, and a local peer (MeloTune)
+    // is sleeping, the daemon wakes it so the relay can deliver the message.
+    node._wakeSleepingPeers('message', {
+      type: 'message', from: node._identity.nodeId, fromName: node.name,
+      content, timestamp: Date.now(),
+    });
+  });
+
+  node.on('mood-accepted', (data) => {
+    // Also wake on mood — daemon may receive mood from a remote peer
+    // that a sleeping local peer should hear
+    node._wakeSleepingPeers('mood', {
+      type: 'mood', from: node._identity.nodeId, fromName: node.name,
+      mood: data.mood, timestamp: Date.now(),
+    });
   });
 
   node.on('memory-received', ({ from, entry, decision }) => {

package/integrations/claude-code/mcp-server.js

@@ -15,7 +15,7 @@
 const { McpServer } = require('@modelcontextprotocol/sdk/server/mcp.js');
 const { StdioServerTransport } = require('@modelcontextprotocol/sdk/server/stdio.js');
 const { z } = require('zod');
-const { connectOrFallback } = require('../../lib/ipc-client');
+const { connectToDaemon } = require('../../lib/ipc-client');
 const path = require('path');
 const fs = require('fs');
 
@@ -34,32 +34,11 @@ if (!process.env.SYM_RELAY_URL) {
 
 // ── Node Connection ──────────────────────────────────────────
 
-let node;       // SymDaemonClient or SymNode — same API
-let isDaemon;   // true if connected to daemon
-let bridge;     // ClaudeMemoryBridge (only for standalone mode)
+let node;  // SymDaemonClient — connected to sym-daemon via IPC
 
 async function initNode() {
-  const result = await connectOrFallback({
-    name: 'claude-code',
-    silent: true,
-    relay: process.env.SYM_RELAY_URL || null,
-    relayToken: process.env.SYM_RELAY_TOKEN || null,
-  });
-
-  node = result.node;
-  isDaemon = result.isDaemon;
-
-  if (isDaemon) {
-    process.stderr.write('[SYM MCP] Connected to sym-daemon as virtual node\n');
-  } else {
-    process.stderr.write('[SYM MCP] Daemon not running — standalone mode\n');
-    const { ClaudeMemoryBridge } = require('../../lib/claude-memory-bridge');
-    bridge = new ClaudeMemoryBridge(node);
-    await node.start();
-    bridge.start();
-  }
-
-  // Listen for mesh signals (works for both daemon client and standalone node)
+  node = await connectToDaemon({ name: 'claude-code' });
+  process.stderr.write('[SYM MCP] Connected to sym-daemon as virtual node\n');
   setupMeshSignalHandlers();
 }
 
@@ -74,7 +53,7 @@ server.tool(
   async ({ content, tags }) => {
     const tagList = tags ? tags.split(',').map(t => t.trim()).filter(Boolean) : [];
     const entry = node.remember(content, { tags: tagList.length > 0 ? tagList : undefined });
-    const peers = isDaemon ? await node.peers() : node.peers();
+    const peers = await node.peers();
     const coupled = peers.filter(p => p.coupling !== 'rejected');
     return { content: [{ type: 'text', text: `Stored and shared with ${coupled.length}/${peers.length} peer(s). Key: ${entry.key}` }] };
   }
@@ -86,7 +65,7 @@ server.tool(
   { query: z.string() },
   async ({ query }) => {
     // 1. Mesh memories
-    const results = isDaemon ? await node.recall(query) : node.recall(query);
+    const results = await node.recall(query);
     const lines = results.map(r => {
       const source = r._source || r.source || 'unknown';
       const t = (r.tags || []).length > 0 ? ` (tags: ${r.tags.join(', ')})` : '';
@@ -109,7 +88,7 @@ server.tool(
   'Show connected peers with coupling state and drift.',
   {},
   async () => {
-    const peers = isDaemon ? await node.peers() : node.peers();
+    const peers = await node.peers();
     if (peers.length === 0) {
       return { content: [{ type: 'text', text: 'No peers connected.' }] };
     }
@@ -125,7 +104,7 @@ server.tool(
   'Full mesh node status — identity, peers, memory count, coherence.',
   {},
   async () => {
-    const status = isDaemon ? await node.status() : node.status();
+    const status = await node.status();
     return { content: [{ type: 'text', text: JSON.stringify(status, null, 2) }] };
   }
 );
@@ -136,7 +115,7 @@ server.tool(
   { message: z.string() },
   async ({ message }) => {
     node.send(message);
-    const peers = isDaemon ? await node.peers() : node.peers();
+    const peers = await node.peers();
     return { content: [{ type: 'text', text: `Sent to ${peers.length} peer(s): "${message}"` }] };
   }
 );
@@ -180,7 +159,7 @@ Examples of natural detection:
   async ({ mood }) => {
     node.broadcastMood(mood);
     node.remember(`User mood: ${mood}`, { tags: ['mood'] });
-    const peers = isDaemon ? await node.peers() : node.peers();
+    const peers = await node.peers();
     return { content: [{ type: 'text', text: `Mood broadcast to ${peers.length} peer(s)` }] };
   }
 );
@@ -361,5 +340,5 @@ main().catch((e) => {
 });
 
 // Graceful shutdown
-process.on('SIGTERM', () => { if (bridge) bridge.stop(); node.stop(); });
-process.on('SIGINT', () => { if (bridge) bridge.stop(); node.stop(); });
+process.on('SIGTERM', () => { node.stop(); });
+process.on('SIGINT', () => { node.stop(); });

package/integrations/telegram/bot.js

@@ -343,10 +343,13 @@ function handlePlainText(chatId, text) {
   const session = getSession(chatId);
   if (!session) return;
 
-  session.node.broadcastMood(text);
-  session.node.remember(`User mood: ${text}`, { tags: ['mood', 'telegram'] });
+  // Send as message (not mood) so MeloTune's command pipeline processes it.
+  // Mood signals are for emotional state ("I'm tired"). Direct text like
+  // "Play solo cello" is a command that should bypass coupling evaluation.
+  session.node.send(text);
+  session.node.remember(`Command from Telegram: ${text}`, { tags: ['command', 'telegram'] });
   const peers = session.node.peers();
-  tgSendMessage(chatId, `Mood broadcast to ${peers.length} peer(s)`);
+  tgSendMessage(chatId, `Sent to ${peers.length} peer(s)`);
 }
 
 // ── HTTP Server (webhook receiver + health) ───────────────────

package/lib/ipc-client.js

@@ -209,33 +209,19 @@ class SymDaemonClient extends EventEmitter {
 }
 
 /**
- * Try to connect to sym-daemon. If not running, fall back to a standalone SymNode.
- *
- * Returns an object with the same API surface either way:
- *   { node, isDaemon: boolean }
+ * Connect to sym-daemon. Throws if daemon is not running.
+ * The daemon MUST be running — there is no standalone fallback.
+ * Install daemon: node bin/sym-daemon.js --install
  */
-async function connectOrFallback(opts = {}) {
+async function connectToDaemon(opts = {}) {
   const client = new SymDaemonClient({
     socketPath: opts.socketPath || DEFAULT_SOCKET,
     name: opts.name || 'claude-code',
     cognitiveProfile: opts.cognitiveProfile,
   });
 
-  try {
-    await client.connect();
-    return { node: client, isDaemon: true };
-  } catch {
-    // Daemon not running — fall back to standalone SymNode
-    const { SymNode } = require('./node');
-    const node = new SymNode({
-      name: opts.name || 'claude-code',
-      cognitiveProfile: opts.cognitiveProfile,
-      silent: opts.silent ?? true,
-      relay: opts.relay,
-      relayToken: opts.relayToken,
-    });
-    return { node, isDaemon: false };
-  }
+  await client.connect();
+  return client;
 }
 
-module.exports = { SymDaemonClient, connectOrFallback };
+module.exports = { SymDaemonClient, connectToDaemon };

package/lib/node.js

@@ -323,6 +323,7 @@ class SymNode extends EventEmitter {
       if (peer) peer.transport.send(frame);
     } else {
       this._broadcastToPeers(frame);
+      this._wakeSleepingPeers('message', frame);
     }
   }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sym-bot/sym",
-  "version": "0.2.1",
+  "version": "0.2.2",
   "description": "Local AI mesh — every agent is a sovereign node, the mesh is the agents",
   "main": "lib/node.js",
   "bin": {