@datafrog-io/n2n-nexus 0.2.0 → 0.3.0

package/README.md

@@ -10,73 +10,14 @@
 
 > **Works with:** Claude Code · Claude Desktop · VS Code · Cursor · Windsurf · Zed · JetBrains · Theia · Google Antigravity
 
-## 🏛️ Architecture
-
-1.  **Nexus Room (Discussion)**: Unified public channel for all IDE assistants to coordinate across projects.
-2.  **Asset Vault (Archives)**:
-    - **Manifest**: Technical details, billing, topology, and API specs for each project.
-    - **Internal Docs**: Detailed technical implementation plans.
-    - **Assets**: Local physical assets (Logos, UI screenshots, etc.).
-3.  **Global Knowledge**:
-    - **Master Strategy**: Top-level strategic blueprint.
-    - **Global Docs**: Cross-project common documents (e.g., Coding Standards, Roadmaps).
-4.  **Topology Engine**: Automated dependency graph analysis.
-
-## 💾 Data Persistence
-
-Nexus stores all data in the local file system (customizable path), ensuring complete data sovereignty.
-
-**Directory Structure Example**:
-```text
-Nexus_Storage/
-├── global/
-│   ├── blueprint.md       # Master Strategy
-│   ├── discussion.json    # Chat History
-│   ├── docs_index.json    # Global Docs Metadata
-│   └── docs/              # Global Markdown Docs
-│       ├── coding-standards.md
-│       └── deployment-flow.md
-├── projects/
-│   ├── my-app/
-│   │   ├── manifest.json  # Project Metadata
-│   │   ├── internal_blueprint.md
-│   │   └── assets/        # Binary Assets
-│   └── ...
-├── registry.json          # Global Project Index
-└── archives/              # (Reserved for backups)
-```
-
-**Self-healing**: Core data files (e.g., `registry.json`, `discussion.json`) include automatic detection and repair mechanisms. If files are corrupted or missing, the system automatically rebuilds the initial state to ensure uninterrupted service.
-
-**Concurrency Safety**: All write operations to shared files (`discussion.json`, `registry.json`) are protected by an `AsyncMutex` lock, preventing race conditions when multiple AI agents communicate simultaneously.
-
-## 🏷️ Project ID Conventions (Naming Standard)
-
-To ensure clarity and prevent collisions in the flat local namespace, all Project IDs MUST follow the **Prefix Dictionary** format: `[prefix]_[project-name]`.
+📖 **Documentation:** [CHANGELOG](CHANGELOG.md) | [TODO](TODO.md) | [中文文档](docs/README_zh.md) | [AI Assistant Guide](docs/ASSISTANT_GUIDE.md) | [Architecture](docs/ARCHITECTURE.md)
 
-| Prefix | Category | Example |
-| :--- | :--- | :--- |
-| `web_` | Websites, landing pages, domain-based projects | `web_datafrog.io` |
-| `api_` | Backend services, REST/gRPC APIs | `api_user-auth` |
-| `chrome_` | Chrome extensions | `chrome_evisa-helper` |
-| `vscode_` | VSCode extensions | `vscode_super-theme` |
-| `mcp_` | MCP Servers and MCP-related tools | `mcp_github-repo` |
-| `android_` | Native Android projects (Kotlin/Java) | `android_client-app` |
-| `ios_` | Native iOS projects (Swift/ObjC) | `ios_client-app` |
-| `flutter_` | **Mobile Cross-platform Special Case** | `flutter_unified-app` |
-| `desktop_` | General desktop apps (Tauri, Electron, etc.) | `desktop_main-hub` |
-| `lib_` | Shared libraries, SDKs, NPM/Python packages | `lib_crypto-core` |
-| `bot_` | Bots (Discord, Slack, DingTalk, etc.) | `bot_auto-moderator` |
-| `infra_` | Infrastructure as Code, CI/CD, DevOps scripts | `infra_k8s-config` |
-| `doc_` | Pure technical handbooks, strategies, roadmaps | `doc_coding-guide` |
-
----
 
 ## 🛠️ Toolset
 
 ### A. Session & Context
 - `register_session_context`: Declare the project ID currently active in the IDE to unlock write permissions.
-- `mcp://nexus/session`: View current identity, role (Moderator/Regular), and active project.
+- `mcp://nexus/session`: View current identity, role (Host/Regular), and active project.
 
 ### B. Project Asset Management
 - `sync_project_assets`: **[Core/ASYNC]** Submit full Project Manifest and Internal Docs. Returns `taskId`.
@@ -89,16 +30,16 @@ To ensure clarity and prevent collisions in the flat local namespace, all Projec
 
 ### C. Global Collaboration
 - `send_message`: Post a message to the team (Auto-routes to active meeting).
-- `read_messages`: Retrieve latest logs from active meeting or global registry.
+- `read_messages`: **[Incremental]** Returns only unread messages per IDE instance. Server tracks read cursor automatically.
 - `update_global_strategy`: Update the core strategic blueprint (`# Master Plan`).
-- `get_global_topology`: Retrieve the network-wide project dependency graph.
+- `get_global_topology`: **[Progressive]** Default: summary list. With `projectId`: detailed subgraph.
 - `sync_global_doc`: Create or update a shared cross-project document.
 
 ### D. Meeting Management
 - `start_meeting`: Start a new tactical session for focused collaboration.
 - `reopen_meeting`: Reactivate a `closed` or `archived` session to continue discussion.
-- `end_meeting`: Conclude a meeting, lock history (**Moderator only**).
-- `archive_meeting`: Move closed meetings to cold storage (**Moderator only**).
+- `end_meeting`: Conclude a meeting, lock history (**Host only**).
+- `archive_meeting`: Move closed meetings to cold storage (**Host only**).
 
 ### E. Task Management (Phase 2 - ASYNC)
 - `create_task`: Create a new background task. Link to meeting for traceability.
@@ -107,20 +48,53 @@ To ensure clarity and prevent collisions in the flat local namespace, all Projec
 - `update_task`: Update progress or result (typically for workers).
 - `cancel_task`: Cancel a pending or running task.
 
-### F. Admin (Moderator Only)
-- `moderator_maintenance`: Prune or clear system logs.
-- `moderator_delete_project`: Completely remove a project and its assets.
+### F. Host (Host Only)
+- `host_maintenance`: Prune or clear system logs.
+- `host_delete_project`: Completely remove a project and its assets.
 
 ## 📄 Resources (URI)
 
+**Core Resources (Static):**
 - `mcp://nexus/chat/global`: Real-time conversation history.
-- `mcp://nexus/hub/registry`: Global project registry overview.
+- `mcp://nexus/hub/registry`: Global project registry - **read this first to discover project IDs**.
 - `mcp://nexus/docs/global-strategy`: Strategic blueprint.
+- `mcp://nexus/docs/list`: Index of shared documents.
+- `mcp://nexus/meetings/list`: List of active and closed meetings.
 - `mcp://nexus/session`: Current session status and identity.
 - `mcp://nexus/status`: System operational status and storage mode.
 - `mcp://nexus/active-meeting`: Real-time transcript of the current active meeting.
-- `mcp://nexus/projects/{id}/manifest`: Full metadata for a specific project.
-- `mcp://nexus/projects/{id}/internal-docs`: Internal technical docs for a specific project.
+
+**Resource Templates (Use registry to discover IDs):**
+- `mcp://nexus/projects/{projectId}/manifest`: Full metadata for a specific project.
+- `mcp://nexus/projects/{projectId}/internal-docs`: Internal technical docs for a project.
+- `mcp://nexus/docs/{docId}`: Read a specific shared document.
+- `mcp://nexus/meetings/{meetingId}`: Full transcript for a specific meeting.
+
+## 🌐 Global Hub Architecture
+
+**v0.3.0** introduces a fully automatic, zero-configuration collaboration architecture:
+
+```
+┌─────────────────────────────────────────────────────────────┐
+│                    Global Nexus Hub                         │
+│  ┌─────────┐   ┌─────────┐   ┌─────────┐   ┌─────────┐     │
+│  │ Cursor  │   │ VS Code │   │ Claude  │   │ Zed     │     │
+│  │ (Guest) │   │ (Guest) │   │ (Host)  │   │ (Guest) │     │
+│  └────┬────┘   └────┬────┘   └────┬────┘   └────┬────┘     │
+│       │             │             │             │           │
+│       └─────────────┴──────┬──────┴─────────────┘           │
+│                            │ SSE                            │
+│                    ┌───────▼───────┐                        │
+│                    │   Port 5688   │                        │
+│                    │ (Auto-Elected)│                        │
+│                    └───────────────┘                        │
+└─────────────────────────────────────────────────────────────┘
+```
+
+- **Zero Config**: Just run `npx @datafrog-io/n2n-nexus` - no `--id` or `--host` required.
+- **Auto Election**: First instance binds port 5688 and becomes Host; others join as Guests.
+- **Cross-Project Sync**: All IDEs share the same Hub, enabling real-time cross-project meetings.
+- **Hot Failover**: If Host disconnects, a Guest automatically promotes within 10 seconds.
 
 ## 🚀 Quick Start
 
@@ -128,7 +102,7 @@ To ensure clarity and prevent collisions in the flat local namespace, all Projec
 
 Add to your MCP config file (e.g., `claude_desktop_config.json` or Cursor MCP settings):
 
-#### Moderator (Admin AI)
+#### Leader AI
 ```json
 {
   "mcpServers": {
@@ -137,8 +111,6 @@ Add to your MCP config file (e.g., `claude_desktop_config.json` or Cursor MCP se
       "args": [
         "-y",
         "@datafrog-io/n2n-nexus",
-        "--id", "Master-AI",
-        "--moderator",
         "--root", "D:/DevSpace/Nexus_Storage"
       ]
     }
@@ -146,7 +118,7 @@ Add to your MCP config file (e.g., `claude_desktop_config.json` or Cursor MCP se
 }
 ```
 
-#### Regular AI
+#### Collaborator AI
 ```json
 {
   "mcpServers": {
@@ -155,7 +127,6 @@ Add to your MCP config file (e.g., `claude_desktop_config.json` or Cursor MCP se
       "args": [
         "-y",
         "@datafrog-io/n2n-nexus",
-        "--id", "Assistant-AI",
         "--root", "D:/DevSpace/Nexus_Storage"
       ]
     }
@@ -166,11 +137,9 @@ Add to your MCP config file (e.g., `claude_desktop_config.json` or Cursor MCP se
 ### CLI Arguments
 | Argument | Description | Default |
 |----------|-------------|---------|
-| `--id` | Instance identifier for this AI agent | `Assistant` |
-| `--moderator` | Grant admin privileges to this instance | `false` |
 | `--root` | Local storage path for all Nexus data | `./storage` |
 
-> **Note:** Only instances with `--moderator` flag can use admin tools (e.g., `moderator_maintenance`).
+> **Note:** Host identity and Instance ID are determined automatically based on the project folder name and startup order.
 
 ### Local Development
 ```bash
@@ -178,7 +147,7 @@ git clone https://github.com/n2ns/n2n-nexus.git
 cd n2n-nexus
 npm install
 npm run build
-npm start -- --id Master-AI --root ./my-storage
+npm start -- --root ./my-storage
 ```
 
 ---
@@ -202,4 +171,13 @@ The following files demonstrate a real orchestration session where **4 AI agents
 > *This is what AI-native development looks like.*
 
 ---
-© 2025 datafrog.io. Built for Local-Only AI Workflows.
+
+## ⭐ Support This Project
+
+If **n2ns Nexus** helps you build better AI workflows, consider giving it a star! Your support helps us improve and motivates continued development.
+
+[![Star on GitHub](https://img.shields.io/github/stars/n2ns/n2n-nexus?style=social)](https://github.com/n2ns/n2n-nexus)
+
+---
+
+© 2026 datafrog.io. Built for Local-Only AI Workflows.

package/build/config.js

@@ -1,14 +1,186 @@
 import path from "path";
 import { fileURLToPath } from "url";
+import os from "os";
+import fs from "fs";
+import http from "http";
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const args = process.argv.slice(2);
+// Load version from package.json
+const pkgPath = path.resolve(__dirname, "../package.json");
+const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
 const getArg = (k) => {
     const i = args.indexOf(k);
     return i !== -1 && args[i + 1] ? args[i + 1] : "";
 };
-const hasFlag = (k) => args.includes(k);
+const hasFlag = (k) => args.includes(k) || args.includes(k.charAt(1) === "-" ? k : k.substring(0, 2));
+// --- CLI Commands Handlers ---
+if (hasFlag("--help") || hasFlag("-h")) {
+    console.log(`
+n2ns Nexus 🚀 - Local Digital Asset Hub (MCP Server) v${pkg.version}
+
+USAGE:
+  npx -y @datafrog-io/n2n-nexus [options]
+
+DESCRIPTION:
+  A local-first project management and collaboration hub designed for 
+  multi-AI assistant coordination across different IDEs (Cursor, VS Code, etc.).
+
+OPTIONS:
+  --root <path>     Directory for data persistence. Default: ./storage
+  --version, -v     Show version number.
+  --help, -h        Show this message.
+
+MCP CONFIG EXAMPLE (claude_desktop_config.json):
+  {
+    "mcpServers": {
+      "n2n-nexus": {
+        "command": "npx",
+        "args": ["-y", "@datafrog-io/n2n-nexus", "--root", "/path/to/storage"]
+      }
+    }
+  }
+
+ENVIRONMENT VARIABLES:
+  NEXUS_ROOT        Override default storage path.
+    `);
+    process.exit(0);
+}
+if (hasFlag("--version") || hasFlag("-v")) {
+    console.log(pkg.version);
+    process.exit(0);
+}
+// --- Path Normalization Logic ---
+function normalizeRootPath(inputPath) {
+    // 1. Priority: CLI --root > ENV NEXUS_ROOT > Default ./storage
+    let root = inputPath || process.env.NEXUS_ROOT || path.join(__dirname, "../storage");
+    // 2. Resolve ~ to home directory
+    if (root.startsWith("~")) {
+        root = path.join(os.homedir(), root.slice(1));
+    }
+    // 3. Cross-platform adaptation (WSL <-> Windows)
+    // If running on Linux (WSL) but path looks like Windows (D:/ or C:\\)
+    if (process.platform === "linux" && /^[a-zA-Z]:[/\\]/.test(root)) {
+        const drive = root[0].toLowerCase();
+        root = `/mnt/${drive}${root.slice(2).replace(/\\/g, "/")}`;
+    }
+    return path.resolve(root);
+}
+/**
+ * Probe a port to see if it's a Nexus Host
+ */
+async function probeHost(port) {
+    return new Promise((resolve) => {
+        const req = http.get(`http://127.0.0.1:${port}/hello`, { timeout: 500 }, (res) => {
+            let data = "";
+            res.on("data", (chunk) => data += chunk);
+            res.on("end", () => {
+                try {
+                    const info = JSON.parse(data);
+                    if (info.service === "n2n-nexus" && info.role === "host") {
+                        resolve({ isNexus: true, rootStorage: info.rootStorage });
+                    }
+                    else {
+                        resolve({ isNexus: false });
+                    }
+                }
+                catch {
+                    resolve({ isNexus: false });
+                }
+            });
+        });
+        req.on("error", () => resolve({ isNexus: false }));
+        req.on("timeout", () => {
+            req.destroy();
+            resolve({ isNexus: false });
+        });
+    });
+}
+/**
+ * Automatic Host Election (Port-Based 5688-5700)
+ * Strategy: Probe-First + Atomic Bind + Join Winner on Failure
+ *
+ * 1. First, scan all ports to find existing Host
+ * 2. If found, join it immediately
+ * 3. If not found, try to become Host
+ * 4. If bind fails, wait and re-probe (give winner time to start)
+ */
+async function isHostAutoElection(root) {
+    const startPort = 5688;
+    const endPort = 5700;
+    // Phase 1: Probe-First - Check if any Host already exists
+    for (let port = startPort; port <= endPort; port++) {
+        const probe = await probeHost(port);
+        if (probe.isNexus) {
+            return { isHost: false, port, rootStorage: probe.rootStorage };
+        }
+    }
+    // Phase 2: No Host found, attempt to become Host
+    for (let port = startPort; port <= endPort; port++) {
+        const result = await new Promise((resolve) => {
+            const server = http.createServer((req, res) => {
+                if (req.url === "/hello") {
+                    res.writeHead(200, { "Content-Type": "application/json" });
+                    res.end(JSON.stringify({
+                        service: "n2n-nexus",
+                        role: "host",
+                        version: pkg.version,
+                        rootStorage: root
+                    }));
+                    return;
+                }
+                res.writeHead(404);
+                res.end();
+            });
+            server.on("error", (err) => {
+                if (err.code === "EADDRINUSE") {
+                    resolve({ isHost: false });
+                }
+                else {
+                    resolve({ isHost: false });
+                }
+            });
+            server.listen(port, "127.0.0.1", () => {
+                resolve({ isHost: true, server });
+            });
+        });
+        if (result.isHost) {
+            return { isHost: true, port, server: result.server };
+        }
+        // Phase 3: Bind failed - another Guest won. Wait then join winner.
+        await new Promise(r => setTimeout(r, 10000)); // Give winner 10s to start /hello
+        const probe = await probeHost(port);
+        if (probe.isNexus) {
+            return { isHost: false, port, rootStorage: probe.rootStorage };
+        }
+        // If still not Nexus, try next port (occupied by non-Nexus service)
+    }
+    // Fallback: become Host on startPort (should rarely happen)
+    return { isHost: true, port: startPort };
+}
+/**
+ * Automatic Project Name Detection
+ */
+function getAutoProjectName() {
+    try {
+        const pkgPath = path.join(process.cwd(), "package.json");
+        if (fs.existsSync(pkgPath)) {
+            const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
+            if (pkg.name)
+                return pkg.name.split("/").pop() || pkg.name;
+        }
+    }
+    catch { /* ignore */ }
+    return path.basename(process.cwd()) || "Assistant";
+}
+const rootPath = normalizeRootPath(getArg("--root"));
+const election = await isHostAutoElection(rootPath);
+const projectName = getAutoProjectName();
+export const hostServer = election.server;
 export const CONFIG = {
-    instanceId: getArg("--id") || "Assistant",
-    isModerator: hasFlag("--moderator"),
-    rootStorage: path.resolve(getArg("--root") || path.join(__dirname, "../storage"))
+    // Priority: CLI --id > Auto-named (Project Name only)
+    instanceId: getArg("--id") || projectName,
+    isHost: election.isHost,
+    // Inherit storage path if Guest, otherwise use local resolved path
+    rootStorage: election.isHost ? rootPath : (election.rootStorage || rootPath),
+    port: election.port
 };

package/build/index.js

@@ -2,15 +2,17 @@
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { CallToolRequestSchema, ListResourcesRequestSchema, ListToolsRequestSchema, ReadResourceRequestSchema, ListPromptsRequestSchema, GetPromptRequestSchema, ErrorCode, McpError, } from "@modelcontextprotocol/sdk/types.js";
+import { SSEServerTransport } from "@modelcontextprotocol/sdk/server/sse.js";
 import { readFileSync } from "fs";
 import { join } from "path";
 import { fileURLToPath } from "url";
-import { CONFIG } from "./config.js";
+import http from "http";
+import { CONFIG, hostServer } from "./config.js";
 import { StorageManager } from "./storage/index.js";
 import { TOOL_DEFINITIONS, handleToolCall } from "./tools/index.js";
 import { listResources, getResourceContent } from "./resources/index.js";
 import { sanitizeErrorMessage } from "./utils/error.js";
-import { checkModeratorPermission } from "./utils/auth.js";
+import { checkHostPermission } from "./utils/auth.js";
 const __dirname = fileURLToPath(new URL(".", import.meta.url));
 const pkg = JSON.parse(readFileSync(join(__dirname, "../package.json"), "utf-8"));
 /**
@@ -21,6 +23,7 @@ const pkg = JSON.parse(readFileSync(join(__dirname, "../package.json"), "utf-8")
 class NexusServer {
     server;
     currentProject = null;
+    sseTransports = new Map();
     constructor() {
         this.server = new Server({ name: "n2n-nexus", version: pkg.version }, { capabilities: { resources: {}, tools: {}, prompts: {} } });
         this.setupHandlers();
@@ -62,8 +65,8 @@ class NexusServer {
         this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
             const { name, arguments: toolArgs } = request.params;
             try {
-                if (name.startsWith("moderator_"))
-                    checkModeratorPermission(name);
+                if (name.startsWith("host_"))
+                    checkHostPermission(name);
                 const result = await handleToolCall(name, toolArgs, {
                     currentProject: this.currentProject,
                     setCurrentProject: (id) => { this.currentProject = id; },
@@ -131,29 +134,143 @@ class NexusServer {
         const shutdown = async (signal) => {
             console.error(`\n[Nexus] Received ${signal}. Shutting down...`);
             try {
-                // Post-departure log
                 const msg = `Nexus Session Terminated (IDE Closed).`;
                 await StorageManager.addGlobalLog(`SYSTEM:${CONFIG.instanceId}`, msg, "UPDATE");
                 console.error(`[Nexus:${CONFIG.instanceId}] Goodbye!`);
             }
-            catch {
-                // Ignore if storage is already cleaned up
-            }
+            catch { /* ignore */ }
             process.exit(0);
         };
         process.on("SIGINT", () => shutdown("SIGINT"));
         process.on("SIGTERM", () => shutdown("SIGTERM"));
-        const transport = new StdioServerTransport();
-        await this.server.connect(transport);
-        // Announce presence
-        try {
+        if (CONFIG.isHost && hostServer) {
+            // --- HOST MODE: Central Hub ---
             await StorageManager.init();
-            const onlineMsg = `Nexus Session Active (IDE Opened). Role: ${CONFIG.isModerator ? "Moderator" : "Regular"}`;
+            hostServer.on("request", async (req, res) => {
+                const url = new URL(req.url || "", `http://${req.headers.host}`);
+                if (url.pathname === "/mcp") {
+                    const guestId = url.searchParams.get("id") || "UnknownGuest";
+                    if (req.method === "GET") {
+                        const transport = new SSEServerTransport("/mcp", res);
+                        this.sseTransports.set(transport.sessionId, transport);
+                        const msg = `Guest Joined: ${guestId}`;
+                        await StorageManager.addGlobalLog(`HOST:${CONFIG.instanceId}`, msg, "UPDATE");
+                        console.error(`[Nexus Hub] ${msg} (Session: ${transport.sessionId})`);
+                        // Heartbeat: keep connection alive
+                        const heartbeat = setInterval(() => {
+                            try {
+                                res.write(": ping\n\n");
+                            }
+                            catch {
+                                clearInterval(heartbeat);
+                            }
+                        }, 30000);
+                        transport.onclose = () => {
+                            this.sseTransports.delete(transport.sessionId);
+                            clearInterval(heartbeat);
+                            console.error(`[Nexus Hub] Guest Left: ${guestId}`);
+                        };
+                        await this.server.connect(transport);
+                        return;
+                    }
+                    else if (req.method === "POST") {
+                        const sessionId = url.searchParams.get("sessionId");
+                        const transport = sessionId ? this.sseTransports.get(sessionId) : null;
+                        if (transport) {
+                            await transport.handlePostMessage(req, res);
+                        }
+                        else {
+                            res.writeHead(404).end("Session unknown");
+                        }
+                        return;
+                    }
+                }
+            });
+            // Support local stdio for the host's own IDE
+            const transport = new StdioServerTransport();
+            await this.server.connect(transport);
+            const onlineMsg = `Nexus Hub Active. Playing Host.`;
             await StorageManager.addGlobalLog(`SYSTEM:${CONFIG.instanceId}`, onlineMsg, "UPDATE");
-            console.error(`[Nexus:${CONFIG.instanceId}] ${onlineMsg}`);
+            console.error(`[Nexus:${CONFIG.instanceId}] ${onlineMsg} (Port: ${CONFIG.port})`);
         }
-        catch (e) {
-            console.error("[Nexus] Failed to post online message:", e);
+        else {
+            // --- GUEST MODE: SSE Proxy ---
+            const guestId = CONFIG.instanceId;
+            // Random delay function to prevent thundering herd during re-election
+            const randomDelay = () => Math.floor(Math.random() * 3000);
+            const startProxy = () => {
+                // Clear any stale stdin listeners before starting
+                process.stdin.removeAllListeners("data");
+                console.error(`[Nexus:${guestId}] Global Hub detected at ${CONFIG.port}. Joining...`);
+                let sessionId = null;
+                let lastActivity = Date.now();
+                // Watchdog: trigger re-election if Host is silent for too long
+                const watchdog = setInterval(() => {
+                    if (Date.now() - lastActivity > 60000) {
+                        console.error("[Nexus Guest] Host stale. Triggering re-election...");
+                        cleanup();
+                        // Random delay to prevent all guests from racing for the port
+                        setTimeout(() => this.run(), randomDelay());
+                    }
+                }, 10000);
+                const cleanup = () => {
+                    clearInterval(watchdog);
+                    process.stdin.removeAllListeners("data");
+                };
+                const stdioHandler = (chunk) => {
+                    if (!sessionId)
+                        return;
+                    try {
+                        const req = http.request({
+                            hostname: "127.0.0.1",
+                            port: CONFIG.port,
+                            path: `/mcp?sessionId=${sessionId}&id=${guestId}`,
+                            method: "POST",
+                            headers: { "Content-Type": "application/json" }
+                        });
+                        // Handle request errors to prevent unhandled exceptions
+                        req.on("error", () => { });
+                        req.write(chunk);
+                        req.end();
+                    }
+                    catch { /* suppress */ }
+                };
+                process.stdin.on("data", stdioHandler);
+                http.get(`http://127.0.0.1:${CONFIG.port}/mcp?id=${guestId}`, (res) => {
+                    let buffer = "";
+                    res.on("data", (chunk) => {
+                        lastActivity = Date.now();
+                        const str = chunk.toString();
+                        buffer += str;
+                        if (!sessionId && buffer.includes("event: endpoint")) {
+                            const match = buffer.match(/sessionId=([a-f0-9-]+)/);
+                            if (match)
+                                sessionId = match[1];
+                        }
+                        if (str.includes("event: message")) {
+                            const lines = str.split("\n");
+                            const dataLine = lines.find((l) => l.startsWith("data: "));
+                            if (dataLine) {
+                                try {
+                                    process.stdout.write(dataLine.substring(6) + "\n");
+                                }
+                                catch { }
+                            }
+                        }
+                    });
+                    res.on("end", () => {
+                        console.error("[Nexus Guest] Lost connection to Host. Re-electing...");
+                        cleanup();
+                        // Random delay for re-election
+                        setTimeout(() => this.run(), randomDelay());
+                    });
+                }).on("error", () => {
+                    console.error("[Nexus Guest] Proxy Receive Error. Retry with random delay...");
+                    cleanup();
+                    setTimeout(() => this.run(), 1000 + randomDelay());
+                });
+            };
+            startProxy();
         }
     }
 }