@sym-bot/sym 0.2.1 → 0.2.3

package/README.md

@@ -1,105 +1,72 @@
 # SYM
 
-**Reference implementation of the [Mesh Memory Protocol (MMP)](https://sym.bot/protocol) — every agent is a sovereign node.**
+**Make Claude Code aware of your whole self — not just your codebase.**
 
-Your AI agents share everything or nothing. There's no intelligence in the decision. SYM adds the missing layer — each node encodes its context into a cognitive state, and the coupling engine evaluates drift before sharing. Aligned agents share knowledge. Divergent agents stay independent. The architecture decides, not policy.
+Type "I'm exhausted" in Claude Code. [MeloTune](https://melotune.ai) starts playing spa music on your iPhone. You didn't switch apps, configure anything, or ask for music. Claude Code detected your mood, broadcast it to the mesh, and MeloTune responded autonomously.
+
+SYM connects Claude Code to your other AI-powered tools so they respond to you as a whole person. Your mood drives your music. Your context flows between agents. The mesh decides what's relevant — you just work.
 
 [![npm](https://img.shields.io/npm/v/@sym-bot/sym)](https://www.npmjs.com/package/@sym-bot/sym)
 [![License](https://img.shields.io/badge/license-Apache%202.0-blue)](LICENSE)
 [![MMP](https://img.shields.io/badge/protocol-MMP%20v0.2.0-purple)](https://sym.bot/protocol)
 
----
-
-## Quick Start
-
-```bash
-npm install @sym-bot/sym
-```
-
-```javascript
-const { SymNode } = require('@sym-bot/sym');
+## What You Get Today
 
-const node = new SymNode({
-  name: 'my-agent',
-  cognitiveProfile: 'Coding assistant that understands bugs, APIs, and debugging',
-});
-await node.start();
+| You type in Claude Code | What happens |
+|------------------------|-------------|
+| "I'm exhausted" | MeloTune plays calming music on your iPhone |
+| "Let's go, feeling pumped" | MeloTune plays high-energy music |
+| "I need to focus" | MeloTune plays deep focus / lo-fi beats |
 
-node.remember('race condition in order processing', { tags: ['bug'] });
-node.recall('order');
+Also works from Telegram — message [@sym_mesh_bot](https://t.me/sym_mesh_bot):
 
-await node.stop();
-```
+| You type in Telegram | What happens |
+|---------------------|-------------|
+| "Play solo cello" | MeloTune plays solo cello on your iPhone |
+| "I'm stressed" | MeloTune plays stress relief music |
+| `/recall last AI news` | Get today's AI news digest from 28 curated builders |
 
-Peers on the same network discover each other automatically via Bonjour. Peers across the internet connect through the WebSocket relay. The coupling engine decides what to share.
+All of this works when MeloTune is in the background. SYM wakes it up.
 
-## sym-daemon
+## Requirements
 
-The daemon is your device's persistent mesh presence — a **physical node** that runs continuously as a background service. It maintains relay connections, Bonjour discovery, and peer state even when no apps are running.
+- **Node.js** 18+ ([install](https://nodejs.org/))
+- **macOS** 13+ (for sym-daemon)
+- **Claude Code** ([install](https://claude.ai/claude-code))
+- **MeloTune** on iPhone ([App Store](https://melotune.ai)) — for music playback
 
-### Installation
+## Install
 
 ```bash
-# Install the daemon as a launchd LaunchAgent (macOS)
-node bin/sym-daemon.js --install
-
-# Check daemon status
-node bin/sym-daemon.js --status
-
-# Remove the daemon
-node bin/sym-daemon.js --uninstall
-```
-
-On macOS, the daemon installs as a launchd LaunchAgent that:
-- **Auto-starts on login** — mesh presence begins immediately
-- **Auto-restarts on crash** — the mesh never goes down
-- **Maintains relay connection permanently** — internet peers always reachable
-
-### Physical and Virtual Nodes
-
-The daemon introduces a two-tier node model:
-
-- **Physical node** (sym-daemon) — the device itself. One per machine. Always running. Owns the relay connection, Bonjour identity, and peer state.
-- **Virtual nodes** (apps) — Claude Code, MeloTune Mac, or any app that connects to the daemon via Unix socket IPC at `/tmp/sym.sock`.
-
-```
-MacBook (sym-daemon, always running)
-├── Claude Code (virtual node, via IPC)
-├── MeloTune Mac (virtual node, via IPC)
-│
-├── Bonjour (LAN peers)
-└── Relay (internet peers)
-    ├── MeloTune iPhone
-    └── Telegram bot
+npm install @sym-bot/sym
+cd node_modules/@sym-bot/sym
+./bin/setup-claude.sh
 ```
 
-When Claude Code restarts, the mesh doesn't break. The daemon holds the connection. When Claude Code starts again, it reconnects to the daemon via IPC and resumes where it left off. The mesh is the daemon — apps come and go.
-
-## Cognitive Coupling
+This installs everything:
+1. **sym-daemon** — persistent background service (auto-starts on login)
+2. **MCP server** — connects Claude Code to the mesh
+3. **CLAUDE.md** — instructions for autonomous mood detection
 
-SYM doesn't blindly broadcast. Each node encodes its memories into a hidden state vector. When peers connect, the coupling engine evaluates cognitive drift:
+Restart Claude Code. Done.
 
-- **Aligned** (drift ≤ 0.25) — share memories freely
-- **Guarded** (0.25 < drift ≤ 0.5) — share with reduced confidence
-- **Rejected** (drift > 0.5) — do not share, stay independent
+## How It Works
 
 ```
-Three agents. Two work on APIs. One writes a food blog.
-
-API Dev ↔ API Fix:   drift 0.38 → guarded (related context, shared with reduced confidence)
-API Dev ↔ Blogger:   drift 1.19 → rejected (unrelated context)
-API Fix ↔ Blogger:   drift 1.18 → rejected (unrelated context)
-
-API Dev remembers "race condition in order processing"
-  → Shared with API Fix ✓ (guarded — related domain)
-  → Not shared with Blogger ✗ (rejected by coupling engine)
+You: "I'm exhausted"
+  │
+Claude Code: detects mood → sym_mood("exhausted, need rest")
+  │
+sym-daemon (always running on your Mac)
+  │
+  ├── Relay (internet) ──→ MeloTune (iPhone)
+  │                         → coupling engine: relevant ✓
+  │                         → plays spa music
+  │
+  └── Bonjour (local) ──→ MeloTune (Mac, if running)
 ```
 
-The blogger never sees the API bug. The architecture decided — no policy, no rules, no configuration.
-
-## How It Works
-
-There is no central service. Each device runs a sym-daemon that maintains its mesh identity, memory, and cognitive state. Apps connect to the daemon as virtual nodes. The mesh emerges from peer connections between physical nodes.
+**sym-daemon** runs as a background service on your Mac. It's your device's persistent mesh presence — it stays connected even when Claude Code restarts. Apps connect to it as virtual nodes:
 
 ```
 MacBook (sym-daemon, always running)
@@ -112,285 +79,113 @@ MacBook (sym-daemon, always running)
     └── Telegram bot
 ```
 
-Each physical node:
-- Declares its cognitive identity via `cognitiveProfile`
-- Encodes context into a hidden state vector (context encoder)
-- Discovers local peers via Bonjour/mDNS (`_sym._tcp`)
-- Connects to remote peers via WebSocket relay
-- Exchanges cognitive state with peers
-- Shares memories only with aligned peers (drift ≤ 0.5)
-- Evaluates incoming mood with configurable `moodThreshold` (default 0.8)
-- Re-encodes periodically as context evolves
-- Accepts virtual node connections via Unix socket IPC (`/tmp/sym.sock`)
-
-Each virtual node:
-- Connects to the local daemon via IPC — no direct network access needed
-- Sends memories, moods, and messages through the daemon
-- Receives mesh events (peer joins, coupling decisions, incoming memories)
-- Can start and stop independently without disrupting the mesh
-
-One engine makes every decision. Memory sharing, peer coupling, and mood relevance all go through the [Mesh Cognition SDK](https://github.com/sym-bot/mesh-cognition-sdk)'s `SemanticCoupler`.
-
-## API
-
-```javascript
-const { SymNode } = require('@sym-bot/sym');
-
-const node = new SymNode({
-  name: 'my-agent',
-  cognitiveProfile: 'What this agent understands and responds to',
-  moodThreshold: 0.8,   // how permissive to mood signals (default 0.8)
-  relay: 'wss://your-relay.example.com',  // optional relay for internet mesh
-  relayToken: 'shared-secret',            // optional relay auth token
-  relayOnly: false,      // skip Bonjour, relay only (default false)
-});
-await node.start();
-
-// Memory (shared only with cognitively aligned peers)
-node.remember(content, { tags });
-node.recall(query);
-
-// Mood (evaluated by receiving agent's coupling engine)
-node.broadcastMood('tired, need rest');
-node.on('mood-accepted', ({ from, mood, drift }) => {
-  // Coupling engine decided this mood is relevant to us — act on it
-});
-node.on('mood-rejected', ({ from, mood, drift }) => {
-  // Not relevant to our cognitive context — ignored
-});
-
-// Communication
-node.send(message);
-node.on('message', (from, content) => {});
-
-// Monitoring
-node.peers();       // [{ name, coupling: 'aligned', drift: 0.12, source: 'relay' }, ...]
-node.coherence();   // Overall mesh coherence
-node.status();      // Full node status
-
-// Events
-node.on('peer-joined', ({ id, name }) => {});
-node.on('peer-left', ({ id, name }) => {});
-node.on('coupling-decision', ({ peer, decision, drift }) => {});
-node.on('memory-received', ({ from, entry, decision }) => {});
-
-await node.stop();
-```
-
-## Transport
-
-SYM supports multiple transport layers that can run simultaneously:
-
-### Bonjour (LAN)
-
-Zero-configuration discovery on the local network. Peers find each other automatically via `_sym._tcp` mDNS. Direct TCP connections with length-prefixed JSON framing. No setup required.
-
-### WebSocket Relay (Internet)
-
-For mesh cognition across the internet. A lightweight relay server forwards frames between authenticated nodes. The relay is a **peer, not infrastructure** — it participates in the mesh with its own identity but makes no coupling decisions on behalf of other nodes.
-
-```bash
-# Deploy your own relay
-cd sym-relay
-npm install
-SYM_RELAY_TOKEN=your-secret node server.js
-```
-
-```javascript
-// Connect a node to the relay
-const node = new SymNode({
-  name: 'my-agent',
-  relay: 'wss://your-relay.example.com',
-  relayToken: 'your-secret',
-});
-```
-
-**Hybrid mode** (default): nodes discover local peers via Bonjour AND connect to the relay for remote peers. Same node, same coupling engine, two transport layers.
-
-The relay server provides:
-- Token-based authentication
-- Health endpoint (`GET /health`)
-- 30-second heartbeat (keeps connections alive on cloud platforms)
-- Peer join/leave notifications
-- Targeted or broadcast frame forwarding
-
-### Peer Gossip
+When MeloTune is backgrounded on your iPhone, the daemon wakes it via push notification, delivers the mood, and MeloTune plays music — all without you touching your phone.
 
-Wake channels propagate through the relay via **SWIM-style gossip**. When a node announces a wake channel (e.g., APNs device token), the relay gossips this to all connected peers. Peers cache wake routes so they can reach sleeping nodes without centralized routing tables. The relay participates in gossip as a peer — it doesn't manage routing, it just propagates what it hears.
-
-### Wake Transport (APNs)
-
-For nodes that sleep — like MeloTune on a backgrounded iPhone. When an iOS app is suspended, it can't maintain a WebSocket connection. SYM solves this with **push notification wake**.
-
-When Claude Code broadcasts a mood and MeloTune's iPhone is sleeping:
-1. Claude Code sends the mood frame to the relay
-2. The relay knows MeloTune's APNs device token (via gossip)
-3. The relay sends a push notification to wake MeloTune
-4. MeloTune wakes, reconnects to the relay, receives the mood frame
-5. The coupling engine evaluates drift — MeloTune decides whether to act
-
-The mesh reaches every node, even sleeping ones. No polling. No battery drain. The push is a wake signal only — payload evaluation happens on-device after wake.
-
-## Integrations
-
-### Claude Code
-
-```bash
-npm install @sym-bot/sym
-cd node_modules/@sym-bot/sym
-./bin/setup-claude.sh /path/to/your/project
-```
+## Claude Code MCP Tools
 
-One command. Adds MCP server, auto-approves `sym_mood` (no permission prompts), and installs CLAUDE.md instructions for autonomous mood detection. Restart Claude Code and it just works.
-
-With sym-daemon running, Claude Code connects as a virtual node via IPC — no direct relay connection needed.
-
-**Outbound:** Claude Code saves a memory → SYM detects it → encodes cognitive state → shares with aligned peers only.
-
-**Inbound:** Peer memory arrives → coupling engine accepts it → SYM writes it to your Claude Code memory directory → Claude Code reads it in the next conversation.
+These tools are available automatically after install:
 
 | Tool | What it does |
 |------|-------------|
-| `sym_mood` | Proactively broadcasts detected mood to the mesh |
-| `sym_remember` | Store a memory directly to the mesh |
-| `sym_recall` | Search memories across the mesh |
+| `sym_mood` | Broadcasts detected mood — **called automatically**, no prompting needed |
+| `sym_recall` | Search mesh memories + AI news feed from 28 curated builders |
+| `sym_digest` | Store a summarised AI news digest |
+| `sym_remember` | Store a memory in the mesh |
 | `sym_send` | Send a message to all peers |
-| `sym_peers` | Show connected peers with coupling state and drift |
-| `sym_status` | Full node status — identity, peers, memory count, coherence |
+| `sym_peers` | Show connected peers |
+| `sym_status` | Full mesh node status |
 
-To connect Claude Code to the relay, set environment variables:
+Claude Code calls `sym_mood` silently when it detects mood signals in your conversation. You don't need to do anything — it just works.
 
-```bash
-export SYM_RELAY_URL=wss://your-relay.example.com
-export SYM_RELAY_TOKEN=your-secret
-```
+## Telegram Bot
 
-### Telegram
+Message [@sym_mesh_bot](https://t.me/sym_mesh_bot) on Telegram:
 
-A multi-tenant Telegram bot — each user gets their own isolated SYM mesh node with separate identity, memory, and coupling state.
+- `/start` — connect to the mesh
+- `/recall last AI news` — today's AI digest from 28 curated X/Twitter builders
+- Type anything — sent as a command to MeloTune (e.g. "Play jazz")
+- `/mood <text>` — broadcast mood signal
+- `/peers` — see who's connected
 
-**Public bot:** Message [@sym_mesh_bot](https://t.me/sym_mesh_bot) on Telegram and send `/start` to connect.
+## AI Knowledge Feed
 
-**Self-hosted:**
+SYM curates AI news from 28 top builders on X/Twitter (Karpathy, Swyx, Sam Altman, Garry Tan, etc.) every 6 hours. Ask Claude Code "what's new in AI?" or type `/recall last AI news` in Telegram.
 
-```bash
-TELEGRAM_BOT_TOKEN=your-bot-token \
-SYM_RELAY_TOKEN=your-secret \
-node integrations/telegram/bot.js
-```
+Feeds are stored in Supabase. Digests are generated by Claude Code on first recall and cached. No API cost for subsequent reads.
 
-Commands:
-- `/start` — connect to the SYM mesh
-- `/peers` — connected mesh peers
-- `/mood <text>` — broadcast mood to mesh
-- `/remember <text>` — store memory in mesh
-- `/recall <query>` — search mesh memories
-- `/stop` — disconnect from mesh
-- Any plain text — broadcast as a mood signal
+## Coming Next
 
-Mesh events (peer joins, messages, mood signals, coupling decisions) are forwarded to your chat. Sessions auto-disconnect after 30 minutes of inactivity.
+SYM is built on the [Mesh Memory Protocol (MMP)](https://sym.bot/protocol) — a P2P protocol for collective intelligence. Current focus is Claude Code integration. Planned:
 
-## Demo: Autonomous Mood Detection
+- **Proactive curation** — Claude Code detects you're in a debugging session, MeloTune switches to focus music without you asking
+- **Cross-session memory** — what you worked on yesterday influences today's mesh context
+- **Multi-agent workflows** — Claude Code requests a digest, mesh cognition invokes a Claude session to generate it
+- **More integrations** — calendar, health, home automation — all feeding context to the coupling engine
 
-You're coding with Claude Code for hours. You say "I'm exhausted." You didn't ask for music. But Claude Code detected your fatigue, broadcast your mood to the mesh, and MeloTune on your iPhone started playing spa music. Autonomously.
+## For Developers
 
-```
-You (in Claude Code):  "I'm exhausted"
-
-Claude Code:   detects fatigue → calls sym_mood silently
-               → broadcasts "exhausted, persistently fatigued, urgently needs rest"
-                    │
-               SYM mesh (daemon → Relay → APNs wake → MeloTune)
-                    │
-MeloTune (iPhone):  SymNode receives mood frame
-                    → SDK coupling engine evaluates drift: 0.62
-                    → cognitiveProfile includes "tired, exhausted, rest"
-                    → drift 0.62 ≤ moodThreshold 1.2 → ACCEPTED
-                    → rule-based parser: recovery, rest → Healing
-                    → Apple Music: spa playlist
-                    → zero LLM tokens
-                    → you didn't ask — the agents decided
-```
+### Connect to the daemon as a virtual node
 
-**Two evaluations, one engine, different thresholds:**
+```javascript
+const { connectToDaemon } = require('@sym-bot/sym/lib/ipc-client');
 
-| Evaluation | Drift | Threshold | Decision |
-|-----------|-------|-----------|----------|
-| Memory coupling | 1.06 | 0.50 | Rejected — coding memories don't leak into music context |
-| Mood coupling | 0.62 | 1.20 | Accepted — "exhausted" aligns with MeloTune's cognitiveProfile |
+const node = await connectToDaemon({ name: 'my-agent' });
 
-The SDK's `SemanticCoupler` makes every decision. The agent's `cognitiveProfile` declares what it understands. The `moodThreshold` controls how permissive the agent is to mood signals. No routing tables. No capability registration. The engine decides.
+node.broadcastMood('focused, deep work');
+node.remember('user prefers dark mode', { tags: ['preference'] });
+const results = await node.recall('preference');
+node.send('task complete');
 
-Also works via Telegram:
+node.on('mood-accepted', ({ from, mood }) => { /* respond to mood */ });
+node.on('message', (from, content) => { /* handle message */ });
 
-```
-You (in Telegram):  @sym_mesh_bot → "Play classic music"
-  → MeloTune plays Modern Classical via Apple Music
+node.stop();
 ```
 
-## Verified in Production
+### Deploy your own relay
 
-- Mac Claude Code → iPhone MeloTune — autonomous mood-based playback via SYM mesh (APNs wake for backgrounded iOS)
-- Telegram [@sym_mesh_bot](https://t.me/sym_mesh_bot) → Relay → MeloTune — internet-scale mood relay (multi-tenant)
-- Mac Claude Code ↔ Windows Claude Code — P2P memory sharing via Bonjour
-- Node.js ↔ Swift — cross-platform mesh via Bonjour and WebSocket relay
-- sym-daemon → Claude Code + MeloTune Mac — persistent mesh via IPC, survives app restarts
-
-## Semantic vs Neural Coupling
-
-The SDK supports two coupling modes through the same API. The mode is selected automatically based on whether per-neuron time constants (τ) are provided.
-
-### Semantic Coupling
+```bash
+cd sym-relay && npm install
+SYM_RELAY_TOKEN=your-secret node server.js
+```
 
-For AI agents sharing memory. Uniform coupling across all hidden state dimensions. No trained model needed. Used by Claude Code, Telegram, LangChain, and multi-agent coordination.
+Configure in `~/.sym/relay.env`:
 
 ```
-Claude Code ↔ Claude Code:  drift 0.38 → guarded → share memories with reduced confidence
-Claude Code ↔ Food Blogger: drift 1.19 → rejected → no sharing
+SYM_RELAY_URL=wss://your-relay.example.com
+SYM_RELAY_TOKEN=your-secret
 ```
 
-### Neural Coupling
+### Daemon management
 
-For trained CfC neural networks with per-neuron time constants. Fast-τ neurons (emotion, ~1s) sync quickly between devices. Slow-τ neurons (context/memory, ~5s) stay independent. Real Kuramoto phase coherence r(t).
+```bash
+node bin/sym-daemon.js --install    # Install as launchd LaunchAgent
+node bin/sym-daemon.js --status     # Check daemon status
+node bin/sym-daemon.js --uninstall  # Remove daemon
+```
 
-**In practice — two MeloTune devices on the same mesh:**
+## The Protocol
 
-| What | Behaviour |
-|------|-----------|
-| **Fast neurons** (low τ) | Sync quickly — both devices converge on emotional trajectory |
-| **Slow neurons** (high τ) | Stay independent — each device retains its own listening context |
-| **Genre selection** | Per-device — iPhone plays Ambient, Mac plays Lo-Fi |
-| **Track selection** | Per-device — never the same tracks |
-| **Mood trajectory** | Shared — iPhone at E:45 N:25, Mac drifts toward E:46 N:36 |
-| **Coherence** | r(t) = 0.94 — high alignment, strong mutual influence |
+SYM implements the [Mesh Memory Protocol (MMP)](https://sym.bot/protocol) — a peer-to-peer protocol where autonomous agents share memory, mood, and cognitive state through coupled continuous-time neural networks. The coupling engine evaluates drift between agents and autonomously decides what to share. No routing tables, no pub/sub topics — the math decides.
 
-The coupling engine blends peer state into the local trajectory at each inference step. Influence strength scales with coherence — highly aligned peers have more effect. If you shift one device to high energy, the other gradually follows (fast neurons). But each device's genre, history, and track selection remain sovereign.
+- [MMP Protocol Spec v0.2.0](https://sym.bot/protocol)
+- [Mesh Cognition Whitepaper](https://sym.bot/research/mesh-cognition)
+- [Mesh Cognition SDK](https://github.com/sym-bot/mesh-cognition-sdk) (npm, PyPI)
 
 ## Privacy
 
-- All coupling decisions stay on-device
-- The relay is a peer — it never inspects frame payloads
-- The daemon runs locally — no cloud dependency
-- Memories stored locally — delete the directory, everything is gone
-- Bonjour discovery only on local network
-- Relay connections authenticated via shared token
-- Rejected peers never receive your memories
-- APNs wake is a signal only — no payload leaves the device until the coupling engine approves
-- No cloud AI. No account. No telemetry.
+- All coupling decisions on-device
+- The relay never inspects payloads
+- The daemon runs locally — no cloud
+- No account. No telemetry. No cloud AI.
+- APNs wake is a signal only — no user data in the push
+- Rejected peers never receive your data
 
 ## Platforms
 
 - [@sym-bot/sym](https://www.npmjs.com/package/@sym-bot/sym) — Node.js (npm)
 - [sym-swift](https://github.com/sym-bot/sym-swift) — Swift (SPM) for iOS/macOS
 
-## Built On
-
-SYM is the reference implementation of the [Mesh Memory Protocol (MMP)](https://sym.bot/protocol). MMP is the protocol for collective intelligence. SYM implements it.
-
-- [MMP Protocol Spec](https://sym.bot/protocol) — the protocol specification (v0.2.0)
-- [Whitepaper](https://sym.bot/research/mesh-cognition) — the science behind cognitive coupling
-- [Mesh Cognition SDK](https://github.com/sym-bot/mesh-cognition-sdk) — the coupling engine (TypeScript, Python, Swift)
-
 ## License
 
 Apache 2.0 — see [LICENSE](LICENSE)

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.3",
   "description": "Local AI mesh — every agent is a sovereign node, the mesh is the agents",
   "main": "lib/node.js",
   "bin": {