@sym-bot/sym 0.2.2 → 0.2.4

package/README.md

@@ -1,105 +1,81 @@
 # 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. [MeloMove](https://melomove.ai) generates a gentle recovery workout. You didn't switch apps, configure anything, or ask for it. Claude Code detected your mood, broadcast it to the mesh, and both agents 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 and your movement. 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)
 
----
+## What You Get Today
 
-## Quick Start
+| You type in Claude Code | What happens |
+|------------------------|-------------|
+| "I'm stressed from debugging" | MeloTune plays stress relief music + MeloMove generates Stress-Busting Home HIIT |
+| "feeling calm, deep work session" | MeloTune plays lo-fi beats + MeloMove suggests Smart Recovery (meditation, yoga) |
+| "I'm exhausted" | MeloTune plays spa music + MeloMove suggests gentle recovery exercises |
+| "Let's go, feeling pumped" | MeloTune plays high-energy music + MeloMove generates a high-intensity workout |
+| "I need to focus" | MeloTune plays deep focus beats + MeloMove suggests a movement break when you surface |
 
-```bash
-npm install @sym-bot/sym
-```
+MeloMove synthesizes an assessment from the mesh mood signal — deriving mood, energy level, and environment context. At nighttime (10pm-6am), it forces indoor/home exercises only. A 10-minute debounce prevents recommendation spam, and mesh mood persists across app restarts.
 
-```javascript
-const { SymNode } = require('@sym-bot/sym');
+Also works from Telegram — message [@sym_mesh_bot](https://t.me/sym_mesh_bot):
 
-const node = new SymNode({
-  name: 'my-agent',
-  cognitiveProfile: 'Coding assistant that understands bugs, APIs, and debugging',
-});
-await node.start();
+| You type in Telegram | What happens |
+|---------------------|-------------|
+| "Play solo cello" | MeloTune plays solo cello on your iPhone |
+| "I'm stressed" | MeloTune plays stress relief music + MeloMove generates a stress-busting workout |
+| `/recall last AI news` | Get today's AI news digest from 28 curated builders |
 
-node.remember('race condition in order processing', { tags: ['bug'] });
-node.recall('order');
+All of this works when MeloTune and MeloMove are in the background. SYM wakes them up.
 
-await node.stop();
-```
+## Requirements
 
-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.
+- **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
+- **MeloMove** on iPhone ([App Store](https://melomove.ai)) — for fitness/wellness
 
-## sym-daemon
-
-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.
-
-### 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
+  │                    │
+  │                    └──→ MeloMove (iPhone)
+  │                          → coupling engine: relevant ✓
+  │                          → generates recovery workout
+  │
+  └── 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)
@@ -108,289 +84,118 @@ MacBook (sym-daemon, always running)
 │
 ├── Bonjour (LAN peers)
 └── Relay (internet peers)
-    ├── MeloTune iPhone
+    ├── MeloTune iPhone (music)
+    ├── MeloMove iPhone (fitness)
     └── 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
-
-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
-```
-
-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.
+When MeloTune or MeloMove is backgrounded on your iPhone, the daemon wakes it via push notification, delivers the mood, and the agent responds — music plays, a workout generates — all without you touching your phone.
 
-**Outbound:** Claude Code saves a memory → SYM detects it → encodes cognitive state → shares with aligned peers only.
+## Claude Code MCP Tools
 
-**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. MeloTune and MeloMove each evaluate the mood independently through their own coupling engines.
 
-```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. Proactive curation is live — Claude Code detects a debugging session, MeloTune switches to focus music, MeloMove suggests a movement break, all without you asking. Planned:
 
-## Demo: Autonomous Mood Detection
+- **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
+- **Health data integration** — Apple Health feeding sleep, HRV, and activity data into the coupling engine
+- **More agents** — calendar, home automation, and third-party agents joining the mesh
 
-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

@@ -117,5 +117,5 @@ 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 "  MeloTune plays calming music, MeloMove suggests recovery exercises."
 echo ""

package/docs/mesh-memory-protocol.md

@@ -87,9 +87,13 @@ MacBook (physical node: sym-daemon)
 ├── MeloTune Mac (virtual node, ephemeral)
 └── Any MCP client (virtual node, ephemeral)
 
-iPhone (physical node: app process)
+iPhone — MeloTune (physical node: app process)
 ├── SymMeshService (virtual, internal)
-└── MMPService (virtual, internal)
+└── Music pipeline (virtual, internal)
+
+iPhone — MeloMove (physical node: app process)
+├── SymMeshService (virtual, internal)
+└── Recommendation engine (virtual, internal)
 
 Cloud Server (physical node: relay process)
 └── Telegram bot (virtual, co-hosted)
@@ -265,7 +269,7 @@ Nodes MUST merge incoming `peer-info` with their local peer knowledge. Wake chan
 }
 ```
 
-MUST NOT send to peers where κ = rejected.
+**SVAF Content-Level Drift:** The sender broadcasts `memory-share` to ALL peers, regardless of peer-level coupling state. The **receiver** evaluates content-level drift independently — encoding the memory content (not the sender's identity) against its own cognitive profile. This allows a cognitively distant peer to accept a relevant memory. Example: Claude Code (coding agent, κ = rejected by MeloMove) shares "user sedentary 2hrs" — MeloMove's content-level drift evaluates the memory itself, finds it relevant to fitness, and accepts it despite high peer drift.
 
 **mood** — emotional/energy state broadcast.
 
@@ -365,7 +369,7 @@ L0 stays local — it is raw, unstructured, and potentially private. L1 is the u
 
 ### Sharing
 
-When a node stores an L1 memory, it evaluates κ(nᵢ, nⱼ) for each peer and sends `memory-share` to those where κ ∈ {aligned, guarded}.
+When a node stores an L1 memory, it broadcasts `memory-share` to all connected peers. The **receiver** evaluates content-level drift (SVAF) — encoding the memory content against its own cognitive profile to determine relevance. This decouples "who sent it" from "is it relevant to me," enabling cross-domain intelligence (e.g. a coding agent's observation about physical inactivity is relevant to a fitness agent).
 
 ### Consistency Model
 
@@ -419,7 +423,31 @@ Properties: **asymmetric**, **dynamic**, **autonomous**. The coupling engine is
 
 Mood bypasses the standard coupling gate with a separate, more permissive threshold θᵤ (default: 0.8). Wellbeing crosses domain boundaries.
 
-### 4.5 Coherence
+### 4.5 SVAF: Content-Level Drift
+
+Peer-level coupling evaluates "should I share with this agent?" — but cognitively distant agents can still share relevant content. SVAF (Symbolic-Vector Attention Fusion) evaluates each memory's content independently:
+
+```
+h_content = E(memory_content)
+δ_content = 1 - cos(h_content, h_local)
+
+if δ_content ≤ θᵤ:  accept (content is relevant to my profile)
+else:               reject (content is not relevant)
+```
+
+This is critical for cross-domain intelligence. Claude Code (coding agent) and MeloMove (fitness agent) have high peer drift (δ ≈ 1.0). But when Claude Code shares "user has been sedentary for 2 hours, stressed from debugging" — MeloMove's content-level drift evaluates the text against its fitness profile and accepts it (δ_content ≈ 0.57 ≤ θᵤ 1.2).
+
+**Production example:**
+```
+Claude Code → sym_remember("user sedentary 2hrs, stressed")
+  → relay → MeloMove
+  → peer drift: 1.05 (rejected — different cognitive domains)
+  → content drift: 0.57 (accepted — "sedentary" + "stressed" relevant to fitness)
+  → MeloMove generates "Stress-Busting Home HIIT" workout
+  → sends push notification: "Time to Move"
+```
+
+### 4.6 Coherence
 
 ```
 C(N') = (1/|N'|) |Σᵢ∈N' exp(iφ̄ⁱ)|    C ∈ [0, 1]

package/lib/node.js

@@ -168,18 +168,14 @@ class SymNode extends EventEmitter {
     this._meshNode.coupledState();
     const decisions = this._meshNode.couplingDecisions;
 
+    // SVAF: send memories to ALL peers. The receiver evaluates content-level
+    // drift and decides relevance. The sender can't know if its content is
+    // relevant to a cognitively distant peer (e.g. "needs movement" from
+    // a coding agent is relevant to a fitness agent despite high peer drift).
     let shared = 0;
     for (const [peerId, peer] of this._peers) {
-      const d = decisions.get(peerId);
-      if (d && d.decision === 'rejected') {
-        this._log(`Not sharing with ${peer.name} — rejected (drift: ${d.drift.toFixed(3)})`);
-        continue;
-      }
       peer.transport.send({ type: 'memory-share', ...entry });
       shared++;
-      if (d) {
-        this._log(`Shared with ${peer.name} — ${d.decision} (drift: ${d.drift.toFixed(3)})`);
-      }
     }
 
     this._log(`Shared: "${content.slice(0, 50)}${content.length > 50 ? '...' : ''}" → ${shared}/${this._peers.size} peers`);
@@ -258,21 +254,11 @@ class SymNode extends EventEmitter {
     this._meshNode.coupledState();
     const decisions = this._meshNode.couplingDecisions;
 
+    // SVAF: send to all peers — receiver evaluates content-level relevance
     let shared = 0;
     for (const [peerId, peer] of this._peers) {
-      const d = decisions.get(peerId);
-
-      if (d && d.decision === 'rejected') {
-        this._log(`Not sharing with ${peer.name} — rejected (drift: ${d.drift.toFixed(3)})`);
-        continue;
-      }
-
       peer.transport.send({ type: 'memory-share', ...entry });
       shared++;
-
-      if (d) {
-        this._log(`Shared with ${peer.name} — ${d.decision} (drift: ${d.drift.toFixed(3)})`);
-      }
     }
 
     this._log(`Remembered: "${content.slice(0, 50)}${content.length > 50 ? '...' : ''}" → ${shared}/${this._peers.size} peers`);
@@ -849,15 +835,31 @@ class SymNode extends EventEmitter {
 
       case 'memory-share':
         if (msg.content) {
-          // Check coupling before accepting
-          const d = this._meshNode.couplingDecisions.get(peerId);
-          if (d && d.decision === 'rejected') {
-            this._log(`Rejected memory from ${peerName} (drift: ${d.drift.toFixed(3)})`);
+          // SVAF-style content-level drift evaluation:
+          // Encode the memory CONTENT (not the sender's state) and evaluate
+          // semantic relevance against our cognitive profile.
+          // This allows cognitively distant agents to share relevant memories.
+          const { h1: memH1, h2: memH2 } = encode(msg.content);
+          const memPeerId = `mem-${peerId}-${Date.now()}`;
+
+          this._meshNode.addPeer(memPeerId, memH1, memH2, 0.8);
+          this._meshNode.coupledState();
+          const contentDrift = this._meshNode.couplingDecisions.get(memPeerId);
+          this._meshNode.removePeer(memPeerId);
+
+          const drift = contentDrift ? contentDrift.drift : 1;
+
+          // Use moodThreshold for content evaluation (more permissive than peer coupling)
+          // because a distant agent can still share relevant observations.
+          if (drift > this._moodThreshold) {
+            this._log(`Rejected memory from ${peerName} — content drift ${drift.toFixed(3)} > ${this._moodThreshold} (content: "${(msg.content || '').slice(0, 40)}...")`);
             break;
           }
+
+          const decision = drift <= 0.25 ? 'aligned' : drift <= 0.5 ? 'guarded' : 'accepted-by-content';
           this._store.receiveFromPeer(peerId, msg);
-          this._log(`Memory from ${peerName}: "${(msg.content || '').slice(0, 40)}..." [${d?.decision || 'accepted'}]`);
-          this.emit('memory-received', { from: peerName, entry: msg, decision: d?.decision });
+          this._log(`Memory from ${peerName}: "${(msg.content || '').slice(0, 40)}..." [${decision}, drift: ${drift.toFixed(3)}]`);
+          this.emit('memory-received', { from: peerName, entry: msg, decision });
         }
         break;
 

package/package.json

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

package/sym-relay/lib/relay.js

@@ -222,7 +222,7 @@ class SymRelay {
     // Offline peers with wake channels (the gossip value-add)
     for (const [id, dir] of this._peerDirectory) {
       if (id === excludeNodeId || seen.has(id)) continue;
-      if (!dir.wakeChannel) continue;
+      if (!dir.wakeChannel || !dir.name) continue;  // Skip entries without name
       peers.push({
         nodeId: id,
         name: dir.name,