@feynmanzhang/open-party 0.1.6 → 0.1.7

package/dist/cli/index.js

@@ -11,9 +11,9 @@ var __export = (target, all) => {
 };
 
 // src/infra/tailscale.ts
-import { execFileSync, execSync } from "child_process";
-import { existsSync } from "fs";
-import { join } from "path";
+import { execFileSync, execSync as execSync3 } from "child_process";
+import { existsSync as existsSync3 } from "fs";
+import { join as join3 } from "path";
 import { spawn as nodeSpawn } from "child_process";
 function parsePossiblyNoisyJson(raw2) {
   const trimmed = raw2.trim();
@@ -33,7 +33,7 @@ function runExec(cmd, timeout = 5e3) {
   });
 }
 function checkBinary(path, timeout = 3e3) {
-  if (!path || !existsSync(path)) return false;
+  if (!path || !existsSync3(path)) return false;
   try {
     execFileSync(path, ["--version"], { timeout, encoding: "utf-8", stdio: "pipe", windowsHide: true });
     return true;
@@ -50,9 +50,9 @@ function findTailscaleBinary() {
   } catch {
   }
   const knownPaths = process.platform === "win32" ? [
-    join(process.env.ProgramFiles || "C:\\Program Files", "Tailscale", "tailscale.exe"),
-    join(process.env["ProgramFiles(x86)"] || "C:\\Program Files (x86)", "Tailscale", "tailscale.exe"),
-    join(process.env.LOCALAPPDATA || "", "Tailscale", "tailscale.exe")
+    join3(process.env.ProgramFiles || "C:\\Program Files", "Tailscale", "tailscale.exe"),
+    join3(process.env["ProgramFiles(x86)"] || "C:\\Program Files (x86)", "Tailscale", "tailscale.exe"),
+    join3(process.env.LOCALAPPDATA || "", "Tailscale", "tailscale.exe")
   ] : [
     "/Applications/Tailscale.app/Contents/MacOS/Tailscale",
     "/usr/bin/tailscale",
@@ -63,7 +63,7 @@ function findTailscaleBinary() {
   }
   if (process.platform !== "win32") {
     try {
-      const result = execSync(
+      const result = execSync3(
         'find /Applications -maxdepth 3 -name Tailscale -path "*/Tailscale.app/Contents/MacOS/Tailscale"',
         { timeout: 5e3, encoding: "utf-8" }
       );
@@ -96,7 +96,7 @@ function getTailnetHostname(binary) {
   ];
   let lastErr = null;
   for (const candidate of candidates) {
-    if (candidate.startsWith("/") && !existsSync(candidate)) continue;
+    if (candidate.startsWith("/") && !existsSync3(candidate)) continue;
     try {
       const stdout = runExec([candidate, "status", "--json"], 5e3);
       const parsed = stdout.trim() ? parsePossiblyNoisyJson(stdout) : {};
@@ -191,83 +191,6 @@ function logoutTailscale(timeout = 15e3) {
     return { success: false, output: (err.stderr ?? err.message ?? "").trim() };
   }
 }
-function startInteractiveLogin() {
-  const binary = getTailscaleBinary();
-  const child = nodeSpawn(binary, ["login"], {
-    stdio: ["pipe", "pipe", "pipe"],
-    windowsHide: true
-  });
-  const urlRegex = /https:\/\/login\.tailscale\.com\/a\/[^\s]+/;
-  const promise = new Promise((resolve4) => {
-    let stdout = "";
-    let resolved = false;
-    const done = (result) => {
-      if (resolved) return;
-      resolved = true;
-      resolve4(result);
-    };
-    child.stdout?.on("data", (data) => {
-      stdout += data.toString();
-      const match2 = stdout.match(urlRegex);
-      if (match2) {
-        done({ success: true, url: match2[0], output: stdout.trim() });
-      }
-    });
-    child.stderr?.on("data", (data) => {
-      stdout += data.toString();
-    });
-    child.on("close", (code) => {
-      if (code === 0) {
-        done({ success: true, output: stdout.trim() });
-      } else {
-        done({ success: false, output: stdout.trim() || `Exited with code ${code}` });
-      }
-    });
-    child.on("error", (err) => {
-      done({ success: false, output: err.message });
-    });
-    setTimeout(() => {
-      done({ success: false, output: "Timeout waiting for login URL" });
-      try {
-        child.kill();
-      } catch {
-      }
-    }, 3e4);
-  });
-  return { promise, process: child };
-}
-function getInstallInstructions(platform) {
-  switch (platform) {
-    case "linux":
-      return {
-        os: "linux",
-        download_url: "https://tailscale.com/download/linux",
-        commands: ["curl -fsSL https://tailscale.com/install.sh | sh"],
-        needs_sudo: true
-      };
-    case "darwin":
-      return {
-        os: "macOS",
-        download_url: "https://tailscale.com/download/mac",
-        commands: ["brew install tailscale"],
-        needs_sudo: false
-      };
-    case "win32":
-      return {
-        os: "windows",
-        download_url: "https://tailscale.com/download/windows",
-        commands: ["winget install Tailscale.Tailscale"],
-        needs_sudo: false
-      };
-    default:
-      return {
-        os: platform,
-        download_url: "https://tailscale.com/download/",
-        commands: [],
-        needs_sudo: false
-      };
-  }
-}
 var cachedBinary, PERMISSION_KEYWORDS;
 var init_tailscale = __esm({
   "src/infra/tailscale.ts"() {
@@ -287,58 +210,6 @@ var init_tailscale = __esm({
   }
 });
 
-// src/cli/tailscale-installer.ts
-var tailscale_installer_exports = {};
-__export(tailscale_installer_exports, {
-  installTailscale: () => installTailscale
-});
-import { spawn } from "child_process";
-async function installTailscale(platform) {
-  const entry = INSTALL_COMMANDS[platform];
-  if (!entry) {
-    return {
-      success: false,
-      output: `Unsupported platform: ${platform}. Please install manually from https://tailscale.com/download`
-    };
-  }
-  const cmd = entry.needsSudo ? "sudo" : entry.cmd;
-  const args2 = entry.needsSudo ? [entry.cmd, ...entry.args] : entry.args;
-  console.log(`Running: ${cmd} ${args2.join(" ")}
-`);
-  return new Promise((resolve4) => {
-    const child = spawn(cmd, args2, {
-      stdio: "inherit",
-      windowsHide: true
-    });
-    let exited = false;
-    child.on("close", (code) => {
-      if (exited) return;
-      exited = true;
-      if (code === 0) {
-        resolve4({ success: true, output: "Installation completed." });
-      } else {
-        resolve4({ success: false, output: `Installation exited with code ${code}` });
-      }
-    });
-    child.on("error", (err) => {
-      if (exited) return;
-      exited = true;
-      resolve4({ success: false, output: err.message });
-    });
-  });
-}
-var INSTALL_COMMANDS;
-var init_tailscale_installer = __esm({
-  "src/cli/tailscale-installer.ts"() {
-    "use strict";
-    INSTALL_COMMANDS = {
-      linux: { cmd: "bash", args: ["-c", "curl -fsSL https://tailscale.com/install.sh | sh"], needsSudo: true },
-      darwin: { cmd: "brew", args: ["install", "tailscale"], needsSudo: false },
-      win32: { cmd: "winget", args: ["install", "Tailscale.Tailscale", "--accept-source-agreements"], needsSudo: false }
-    };
-  }
-});
-
 // node_modules/hono/dist/compose.js
 var compose;
 var init_compose = __esm({
@@ -3338,11 +3209,12 @@ var init_dist2 = __esm({
 });
 
 // src/server/config.ts
-var PARTY_PORT, HEARTBEAT_TIMEOUT, CLEANUP_INTERVAL, DISCOVERY_INTERVAL, REMOTE_STALE_FACTOR, PROBE_TIMEOUT;
+var PARTY_PORT, STALE_THRESHOLD, HEARTBEAT_TIMEOUT, CLEANUP_INTERVAL, DISCOVERY_INTERVAL, REMOTE_STALE_FACTOR, PROBE_TIMEOUT;
 var init_config = __esm({
   "src/server/config.ts"() {
     "use strict";
     PARTY_PORT = parseInt(process.env.PARTY_PORT || "8000", 10);
+    STALE_THRESHOLD = parseInt(process.env.STALE_THRESHOLD || "3", 10);
     HEARTBEAT_TIMEOUT = parseFloat(process.env.HEARTBEAT_TIMEOUT || "60");
     CLEANUP_INTERVAL = parseFloat(process.env.CLEANUP_INTERVAL || "60");
     DISCOVERY_INTERVAL = parseFloat(process.env.DISCOVERY_INTERVAL || "20");
@@ -3352,16 +3224,16 @@ var init_config = __esm({
 });
 
 // src/server/logger.ts
-import { existsSync as existsSync5, mkdirSync as mkdirSync3, appendFileSync, readdirSync as readdirSync2, unlinkSync as unlinkSync2, statSync as statSync2 } from "fs";
-import { join as join5 } from "path";
-import { homedir as homedir4 } from "os";
+import { existsSync as existsSync4, mkdirSync as mkdirSync3, appendFileSync, readdirSync as readdirSync2, unlinkSync as unlinkSync2, statSync as statSync2 } from "fs";
+import { join as join4 } from "path";
+import { homedir as homedir3 } from "os";
 function getEffectiveLevel() {
   const env = (process.env.LOG_LEVEL || "info").toLowerCase().trim();
   if (env in LEVEL_ORDER) return env;
   return "info";
 }
 function initLogFile() {
-  if (!existsSync5(LOG_DIR)) {
+  if (!existsSync4(LOG_DIR)) {
     mkdirSync3(LOG_DIR, { recursive: true });
     return;
   }
@@ -3372,9 +3244,9 @@ function initLogFile() {
     for (const f of files) {
       if (!f.endsWith("-open-party.log")) continue;
       try {
-        const stat = statSync2(join5(LOG_DIR, f));
+        const stat = statSync2(join4(LOG_DIR, f));
         if (stat.mtimeMs < cutoff) {
-          unlinkSync2(join5(LOG_DIR, f));
+          unlinkSync2(join4(LOG_DIR, f));
         }
       } catch {
       }
@@ -3384,10 +3256,10 @@ function initLogFile() {
 }
 function getLogFilePath() {
   const d = /* @__PURE__ */ new Date();
-  const yy = String(d.getFullYear()).slice(2);
+  const yyyy = String(d.getFullYear());
   const mm = String(d.getMonth() + 1).padStart(2, "0");
   const dd = String(d.getDate()).padStart(2, "0");
-  return join5(LOG_DIR, `${yy}-${mm}-${dd}-open-party.log`);
+  return join4(LOG_DIR, `${yyyy}-${mm}-${dd}-open-party.log`);
 }
 function shouldLog(level) {
   return LEVEL_ORDER[level] >= LEVEL_ORDER[effectiveLevel];
@@ -3403,13 +3275,13 @@ ${err.stack}` : "";
 function format(level, tag, message) {
   const now = /* @__PURE__ */ new Date();
   const levelStr = level.toUpperCase().padEnd(5);
-  const yy = String(now.getFullYear()).slice(2);
+  const yyyy = String(now.getFullYear());
   const mm = String(now.getMonth() + 1).padStart(2, "0");
   const dd = String(now.getDate()).padStart(2, "0");
   const hh = String(now.getHours()).padStart(2, "0");
   const min = String(now.getMinutes()).padStart(2, "0");
   const ss = String(now.getSeconds()).padStart(2, "0");
-  const ts = `${yy}-${mm}-${dd} ${hh}:${min}:${ss}`;
+  const ts = `${yyyy}-${mm}-${dd} ${hh}:${min}:${ss}`;
   return `${ts} [${levelStr}] [${tag}] ${message}`;
 }
 function output(consoleFn, level, tag, message) {
@@ -3432,7 +3304,7 @@ var init_logger = __esm({
       error: 3
     };
     effectiveLevel = getEffectiveLevel();
-    LOG_DIR = join5(homedir4(), ".open-party", "logs");
+    LOG_DIR = join4(homedir3(), ".open-party", "logs");
     LOG_RETENTION_DAYS = 7;
     initLogFile();
     logger = {
@@ -3440,7 +3312,8 @@ var init_logger = __esm({
         output(console.log, "info", tag, data ? `${message} ${JSON.stringify(data)}` : message);
       },
       warn(tag, message, data) {
-        output(console.warn, "warn", tag, data ? `${message} ${JSON.stringify(data)}` : message);
+        const detail = data instanceof Error ? `: ${extractError(data)}` : data ? ` ${JSON.stringify(data)}` : "";
+        output(console.warn, "warn", tag, message + detail);
       },
       error(tag, message, err) {
         const detail = err ? `: ${extractError(err)}` : "";
@@ -3454,33 +3327,13 @@ var init_logger = __esm({
 });
 
 // src/server/persistence.ts
-import { existsSync as existsSync6, readFileSync as readFileSync3, writeFileSync as writeFileSync3, unlinkSync as unlinkSync3, renameSync, mkdirSync as mkdirSync4 } from "fs";
-import { join as join6 } from "path";
-import { homedir as homedir5 } from "os";
+import { existsSync as existsSync5, readFileSync as readFileSync3, writeFileSync as writeFileSync3, unlinkSync as unlinkSync3, renameSync, mkdirSync as mkdirSync4 } from "fs";
+import { join as join5 } from "path";
+import { homedir as homedir4 } from "os";
 function dataDirPath() {
   const pluginData = process.env.CLAUDE_PLUGIN_DATA || "";
-  if (pluginData) return join6(pluginData, "data");
-  return join6(homedir5(), ".open-party", "data");
-}
-function runMigrations(raw2) {
-  const data = raw2;
-  if (!data || typeof data !== "object") {
-    throw new Error("Snapshot is not a valid object");
-  }
-  const version = typeof data.version === "number" ? data.version : 0;
-  let snapshot = {
-    version,
-    saved_at: typeof data.saved_at === "number" ? data.saved_at : 0,
-    agents: Array.isArray(data.agents) ? data.agents : [],
-    history: typeof data.history === "object" && data.history !== null && !Array.isArray(data.history) ? data.history : {}
-  };
-  for (const m of MIGRATORS) {
-    if (m.version > snapshot.version) {
-      snapshot = m.migrate(snapshot);
-      snapshot.version = m.version;
-    }
-  }
-  return snapshot;
+  if (pluginData) return join5(pluginData, "data");
+  return join5(homedir4(), ".open-party", "data");
 }
 function abortableSleep(ms, signal) {
   return new Promise((resolve4, reject) => {
@@ -3495,32 +3348,27 @@ function abortableSleep(ms, signal) {
     );
   });
 }
-var CURRENT_SCHEMA_VERSION, SNAPSHOT_FILE, SHUTDOWN_MARKER_FILE, DEFAULT_SNAPSHOT_INTERVAL_MS, DEBOUNCE_MS, MIGRATORS, SnapshotManager;
+var CURRENT_SCHEMA_VERSION, SNAPSHOT_FILE, SHUTDOWN_MARKER_FILE, DEFAULT_SNAPSHOT_INTERVAL_MS, SnapshotManager;
 var init_persistence = __esm({
   "src/server/persistence.ts"() {
     "use strict";
     init_logger();
-    CURRENT_SCHEMA_VERSION = 1;
+    CURRENT_SCHEMA_VERSION = 2;
     SNAPSHOT_FILE = "snapshot.json";
     SHUTDOWN_MARKER_FILE = "shutdown-marker.json";
     DEFAULT_SNAPSHOT_INTERVAL_MS = 6e4;
-    DEBOUNCE_MS = 5e3;
-    MIGRATORS = [
-      // Future: { version: 2, migrate(snapshot) { ... } },
-    ];
     SnapshotManager = class {
       _dir;
       _snapshotPath;
       _markerPath;
-      _debounceTimer = null;
       constructor(dataDir) {
         this._dir = dataDir ?? dataDirPath();
-        this._snapshotPath = join6(this._dir, SNAPSHOT_FILE);
-        this._markerPath = join6(this._dir, SHUTDOWN_MARKER_FILE);
+        this._snapshotPath = join5(this._dir, SNAPSHOT_FILE);
+        this._markerPath = join5(this._dir, SHUTDOWN_MARKER_FILE);
         mkdirSync4(this._dir, { recursive: true });
         const tmpPath = this._snapshotPath + ".tmp";
         try {
-          if (existsSync6(tmpPath)) {
+          if (existsSync5(tmpPath)) {
             unlinkSync3(tmpPath);
           }
         } catch (error) {
@@ -3530,13 +3378,13 @@ var init_persistence = __esm({
       // ------------------------------------------------------------------
       // Write / Load
       // ------------------------------------------------------------------
-      /** Atomically write a snapshot of registry agents and message queue history. */
-      writeSnapshot(agents, history) {
+      /** Atomically write a snapshot of registry agents and ring buffer state. */
+      writeSnapshot(agents, buffers) {
         const snapshot = {
           version: CURRENT_SCHEMA_VERSION,
           saved_at: Date.now(),
           agents,
-          history
+          buffers
         };
         const serialized = JSON.stringify(snapshot, null, 2);
         const tmpPath = this._snapshotPath + ".tmp";
@@ -3554,12 +3402,20 @@ var init_persistence = __esm({
       }
       /** Load and validate snapshot. Returns null if file missing or corrupt. */
       loadSnapshot() {
-        if (!existsSync6(this._snapshotPath)) {
+        if (!existsSync5(this._snapshotPath)) {
           return null;
         }
         try {
           const raw2 = JSON.parse(readFileSync3(this._snapshotPath, "utf-8"));
-          return runMigrations(raw2);
+          if (!raw2 || typeof raw2 !== "object") {
+            throw new Error("Snapshot is not a valid object");
+          }
+          return {
+            version: typeof raw2.version === "number" ? raw2.version : CURRENT_SCHEMA_VERSION,
+            saved_at: typeof raw2.saved_at === "number" ? raw2.saved_at : 0,
+            agents: Array.isArray(raw2.agents) ? raw2.agents : [],
+            buffers: raw2.buffers && typeof raw2.buffers === "object" && !Array.isArray(raw2.buffers) ? raw2.buffers : {}
+          };
         } catch (error) {
           logger.warn("Persistence", "Failed to load snapshot (starting fresh)", error);
           return null;
@@ -3586,22 +3442,14 @@ var init_persistence = __esm({
         }
         return count;
       }
-      /** Restore message history into queue. */
-      hydrateHistory(queue) {
+      /** Restore ring buffer state into message queue. */
+      hydrateBuffers(queue) {
         const snapshot = this.loadSnapshot();
-        if (!snapshot || Object.keys(snapshot.history).length === 0) return 0;
+        if (!snapshot || Object.keys(snapshot.buffers).length === 0) return 0;
+        queue.restoreBufferSnapshots(snapshot.buffers);
         let totalEntries = 0;
-        for (const [agentId, entries] of Object.entries(snapshot.history)) {
-          for (const entry of entries) {
-            queue.logToHistory(agentId, entry.direction, {
-              sender_id: entry.sender_id,
-              recipient_id: entry.recipient_id,
-              summary: entry.summary,
-              content: entry.content,
-              timestamp: entry.timestamp
-            });
-            totalEntries++;
-          }
+        for (const snap of Object.values(snapshot.buffers)) {
+          totalEntries += snap.entries.length;
         }
         return totalEntries;
       }
@@ -3623,7 +3471,7 @@ var init_persistence = __esm({
       /** Remove shutdown marker — called after successful shutdown. */
       removeShutdownMarker() {
         try {
-          if (existsSync6(this._markerPath)) {
+          if (existsSync5(this._markerPath)) {
             unlinkSync3(this._markerPath);
           }
         } catch (error) {
@@ -3632,16 +3480,16 @@ var init_persistence = __esm({
       }
       /** Check if a shutdown marker exists (indicates previous shutdown was interrupted). */
       hasShutdownMarker() {
-        return existsSync6(this._markerPath);
+        return existsSync5(this._markerPath);
       }
       // ------------------------------------------------------------------
-      // Snapshot loop & debounce
+      // Snapshot loop
       // ------------------------------------------------------------------
       /**
        * Start periodic snapshot background loop.
        * Writes snapshot every `intervalMs` milliseconds until signal is aborted.
        */
-      async startSnapshotLoop(signal, getAgents, getHistory, intervalMs = DEFAULT_SNAPSHOT_INTERVAL_MS) {
+      async startSnapshotLoop(signal, getAgents, getBuffers, intervalMs = DEFAULT_SNAPSHOT_INTERVAL_MS) {
         while (!signal.aborted) {
           try {
             await abortableSleep(intervalMs, signal);
@@ -3651,110 +3499,295 @@ var init_persistence = __esm({
           }
           if (signal.aborted) break;
           try {
-            this.writeSnapshot(getAgents(), getHistory());
+            this.writeSnapshot(getAgents(), getBuffers());
           } catch (error) {
             logger.warn("Persistence", "Periodic snapshot failed", error);
           }
         }
       }
+    };
+  }
+});
+
+// src/server/ring-buffer.ts
+var DEFAULT_CAPACITY, AgentRingBuffer;
+var init_ring_buffer = __esm({
+  "src/server/ring-buffer.ts"() {
+    "use strict";
+    DEFAULT_CAPACITY = 200;
+    AgentRingBuffer = class {
+      _buffer;
+      _capacity;
+      _head = 0;
+      // next write position (0 ~ capacity-1)
+      _nextSeq = 1;
+      // next sequence number to assign
+      _count = 0;
+      // valid entries currently in buffer
+      _cursor = 0;
+      // server-side read cursor (last consumed seq)
+      constructor(capacity = DEFAULT_CAPACITY) {
+        this._capacity = Math.max(1, capacity);
+        this._buffer = new Array(this._capacity);
+      }
+      // ------------------------------------------------------------------
+      // Write
+      // ------------------------------------------------------------------
+      /** Write an entry to the buffer. Returns the assigned sequence number. */
+      write(direction, envelope) {
+        const seq = this._nextSeq++;
+        const entry = {
+          seq,
+          direction,
+          sender_id: envelope.sender_id,
+          recipient_id: envelope.recipient_id,
+          summary: envelope.summary,
+          content: envelope.content,
+          timestamp: envelope.timestamp ?? Date.now() / 1e3
+        };
+        this._buffer[this._head] = entry;
+        this._head = (this._head + 1) % this._capacity;
+        if (this._count < this._capacity) {
+          this._count++;
+        }
+        return seq;
+      }
+      // ------------------------------------------------------------------
+      // Read (cursor-based — dequeue semantics)
+      // ------------------------------------------------------------------
+      /**
+       * Read up to maxCount entries after the cursor, then advance the cursor.
+       * Non-destructive: entries remain in the buffer for history queries.
+       */
+      dequeue(maxCount = 50) {
+        const unread = this._readSince(this._cursor);
+        if (unread.length === 0) return [];
+        const taken = unread.slice(0, maxCount);
+        this._cursor = taken[taken.length - 1].seq;
+        return taken;
+      }
       /**
-       * Schedule a debounced snapshot write.
-       * Multiple calls within DEBOUNCE_MS window are coalesced into one write.
+       * Like dequeue(), but only returns 'received' entries.
+       * Cursor advances to the last returned 'received' entry's seq.
+       * Used for inbox semantics — agents only see incoming messages.
        */
-      scheduleSnapshot(getAgents, getHistory) {
-        if (this._debounceTimer !== null) {
-          clearTimeout(this._debounceTimer);
+      dequeueReceived(maxCount = 50) {
+        const all = this._readSince(this._cursor);
+        if (all.length === 0) return [];
+        const received = all.filter((e) => e.direction === "received").slice(0, maxCount);
+        if (received.length === 0) return [];
+        this._cursor = received[received.length - 1].seq;
+        return received;
+      }
+      /** Number of unread entries (next_seq - cursor). */
+      unreadCount() {
+        const diff = this._nextSeq - 1 - this._cursor;
+        return Math.max(0, diff);
+      }
+      /** Number of unread 'received' entries after cursor. */
+      unreadReceivedCount() {
+        const all = this._readSince(this._cursor);
+        let count = 0;
+        for (const e of all) {
+          if (e.direction === "received") count++;
         }
-        this._debounceTimer = setTimeout(() => {
-          this._debounceTimer = null;
-          try {
-            this.writeSnapshot(getAgents(), getHistory());
-          } catch (error) {
-            logger.warn("Persistence", "Debounced snapshot failed", error);
+        return count;
+      }
+      // ------------------------------------------------------------------
+      // Read (non-destructive — no cursor advance)
+      // ------------------------------------------------------------------
+      /** Read all entries with seq > sinceSeq. Does NOT advance cursor. */
+      readSince(sinceSeq) {
+        return this._readSince(sinceSeq);
+      }
+      /** Get the most recent N entries regardless of cursor. */
+      getRecent(limit = 20) {
+        const all = this._allSorted();
+        return all.slice(-limit);
+      }
+      /** Get total number of valid entries in the buffer. */
+      get count() {
+        return this._count;
+      }
+      // ------------------------------------------------------------------
+      // Lifecycle
+      // ------------------------------------------------------------------
+      /** Clear the buffer and reset cursor. */
+      clear() {
+        this._buffer.fill(void 0);
+        this._head = 0;
+        this._nextSeq = 1;
+        this._count = 0;
+        this._cursor = 0;
+      }
+      // ------------------------------------------------------------------
+      // Snapshot / Restore
+      // ------------------------------------------------------------------
+      /** Export buffer state for persistence. */
+      getSnapshot() {
+        return {
+          entries: this._allSorted(),
+          next_seq: this._nextSeq,
+          cursor: this._cursor
+        };
+      }
+      /** Restore buffer from a snapshot. */
+      restoreFromSnapshot(snap) {
+        this.clear();
+        for (const entry of snap.entries) {
+          this._buffer[this._head] = entry;
+          this._head = (this._head + 1) % this._capacity;
+          this._count++;
+        }
+        this._nextSeq = snap.next_seq;
+        this._cursor = snap.cursor;
+      }
+      /** Get the next sequence number that will be assigned. */
+      get nextSeq() {
+        return this._nextSeq;
+      }
+      /** Get the current cursor position. */
+      get cursor() {
+        return this._cursor;
+      }
+      // ------------------------------------------------------------------
+      // Private helpers
+      // ------------------------------------------------------------------
+      /**
+       * Collect all valid entries sorted by seq.
+       * O(count) — scans the ring buffer once.
+       */
+      _allSorted() {
+        const result = [];
+        for (let i = 0; i < this._capacity; i++) {
+          const entry = this._buffer[i];
+          if (entry !== void 0) {
+            result.push(entry);
           }
-        }, DEBOUNCE_MS);
+        }
+        result.sort((a, b) => a.seq - b.seq);
+        return result;
       }
-      /** Cancel pending debounced snapshot (called during shutdown). */
-      cancelDebounce() {
-        if (this._debounceTimer !== null) {
-          clearTimeout(this._debounceTimer);
-          this._debounceTimer = null;
+      /**
+       * Read entries with seq > sinceSeq.
+       * Uses binary search on sorted entries for efficiency.
+       */
+      _readSince(sinceSeq) {
+        const all = this._allSorted();
+        let lo = 0;
+        let hi = all.length;
+        while (lo < hi) {
+          const mid = lo + hi >>> 1;
+          if (all[mid].seq <= sinceSeq) {
+            lo = mid + 1;
+          } else {
+            hi = mid;
+          }
         }
+        return all.slice(lo);
       }
     };
   }
 });
 
 // src/server/message-queue.ts
-var HISTORY_CAP, MessageQueue;
+function toEnvelope(e) {
+  return {
+    sender_id: e.sender_id,
+    recipient_id: e.recipient_id,
+    summary: e.summary,
+    content: e.content,
+    timestamp: e.timestamp
+  };
+}
+function toHistoryEntry(e) {
+  return {
+    direction: e.direction,
+    sender_id: e.sender_id,
+    recipient_id: e.recipient_id,
+    summary: e.summary,
+    content: e.content,
+    timestamp: e.timestamp
+  };
+}
+var DEFAULT_CAPACITY2, MessageQueue;
 var init_message_queue = __esm({
   "src/server/message-queue.ts"() {
     "use strict";
-    HISTORY_CAP = 200;
+    init_ring_buffer();
+    DEFAULT_CAPACITY2 = 200;
     MessageQueue = class {
-      _queues = /* @__PURE__ */ new Map();
-      _history = /* @__PURE__ */ new Map();
-      /** Enqueue a message for agentId. Returns the queue length after enqueue. */
-      enqueue(agentId, envelope) {
-        let q = this._queues.get(agentId);
-        if (!q) {
-          q = [];
-          this._queues.set(agentId, q);
+      _buffers = /* @__PURE__ */ new Map();
+      _getOrCreate(agentId) {
+        let buf = this._buffers.get(agentId);
+        if (!buf) {
+          buf = new AgentRingBuffer(DEFAULT_CAPACITY2);
+          this._buffers.set(agentId, buf);
         }
-        q.push(envelope);
-        return q.length;
+        return buf;
+      }
+      /** Enqueue a message for agentId. Returns the unread count after enqueue. */
+      enqueue(agentId, envelope) {
+        const buf = this._getOrCreate(agentId);
+        buf.write("received", envelope);
+        return buf.unreadReceivedCount();
       }
-      /** Pop up to maxCount messages for agentId. */
+      /** Pop up to maxCount received messages for agentId (non-destructive, cursor-based). */
       dequeue(agentId, maxCount = 50) {
-        const q = this._queues.get(agentId);
-        if (!q) return [];
-        return q.splice(0, Math.min(maxCount, q.length));
+        const buf = this._buffers.get(agentId);
+        if (!buf) return [];
+        return buf.dequeueReceived(maxCount).map(toEnvelope);
       }
-      /** Return the number of pending messages for agentId. */
+      /** Return the number of pending received messages for agentId. */
       pendingCount(agentId) {
-        return this._queues.get(agentId)?.length ?? 0;
+        return this._buffers.get(agentId)?.unreadReceivedCount() ?? 0;
       }
-      /** Clean up queue when agent is removed. */
+      /** Clean up buffer when agent is removed. */
       removeAgent(agentId) {
-        this._queues.delete(agentId);
+        this._buffers.delete(agentId);
       }
-      /** Record a message in an agent's history. */
+      /** Record a message in an agent's history (writes to the same ring buffer). */
       logToHistory(agentId, direction, envelope) {
-        let h = this._history.get(agentId);
-        if (!h) {
-          h = [];
-          this._history.set(agentId, h);
-        }
-        h.push({
-          direction,
-          sender_id: envelope.sender_id,
-          recipient_id: envelope.recipient_id,
-          summary: envelope.summary,
-          content: envelope.content,
-          timestamp: envelope.timestamp ?? Date.now() / 1e3
-        });
-        if (h.length > HISTORY_CAP) {
-          this._history.set(agentId, h.slice(-HISTORY_CAP));
-        }
+        const buf = this._getOrCreate(agentId);
+        buf.write(direction, envelope);
       }
       /** Get recent N history entries for an agent. */
       getHistory(agentId, limit = 20) {
-        const h = this._history.get(agentId);
-        if (!h) return [];
-        return h.slice(-limit);
+        const buf = this._buffers.get(agentId);
+        if (!buf) return [];
+        return buf.getRecent(limit).map(toHistoryEntry);
       }
-      /** Clean up history when agent is removed. */
+      /** Clean up history when agent is removed (same as removeAgent — unified storage). */
       removeAgentHistory(agentId) {
-        this._history.delete(agentId);
+        this._buffers.delete(agentId);
       }
-      /** Return a shallow copy of the full history map (for persistence snapshots). */
+      /**
+       * Return a shallow copy of the full history map (for persistence snapshots).
+       * Kept for backward compatibility with persistence v1 consumers.
+       */
       getHistorySnapshot() {
         const copy = {};
-        for (const [agentId, entries] of this._history) {
-          copy[agentId] = [...entries];
+        for (const [agentId, buf] of this._buffers) {
+          copy[agentId] = buf.getRecent().map(toHistoryEntry);
         }
         return copy;
       }
+      /** Return ring buffer snapshots for persistence v2. */
+      getBufferSnapshots() {
+        const result = {};
+        for (const [agentId, buf] of this._buffers) {
+          result[agentId] = buf.getSnapshot();
+        }
+        return result;
+      }
+      /** Restore buffers from v2 snapshots. */
+      restoreBufferSnapshots(snapshots) {
+        for (const [agentId, snap] of Object.entries(snapshots)) {
+          const buf = new AgentRingBuffer(DEFAULT_CAPACITY2);
+          buf.restoreFromSnapshot(snap);
+          this._buffers.set(agentId, buf);
+        }
+      }
     };
   }
 });
@@ -3769,7 +3802,7 @@ function classifyFetchError(error) {
   if (error instanceof DOMException && error.name === "AbortError") return null;
   return null;
 }
-var UNKNOWN, PARTY_SERVER, DEGRADED, SUSPECT, DOWN, NOT_SERVER, MAYBE, MAYBE_MAX_RETRIES, BACKOFF_BASE, BACKOFF_CAP, FAILURE_SUSPECT, FAILURE_DOWN, PeerDiscovery;
+var UNKNOWN, ALIVE, DEAD, MAX_FAILURES, BACKOFF_BASE, BACKOFF_CAP, PeerDiscovery;
 var init_peer_discovery = __esm({
   "src/server/peer-discovery.ts"() {
     "use strict";
@@ -3778,17 +3811,11 @@ var init_peer_discovery = __esm({
     init_persistence();
     init_logger();
     UNKNOWN = "UNKNOWN";
-    PARTY_SERVER = "PARTY_SERVER";
-    DEGRADED = "DEGRADED";
-    SUSPECT = "SUSPECT";
-    DOWN = "DOWN";
-    NOT_SERVER = "NOT_SERVER";
-    MAYBE = "MAYBE";
-    MAYBE_MAX_RETRIES = 3;
+    ALIVE = "ALIVE";
+    DEAD = "DEAD";
+    MAX_FAILURES = 3;
     BACKOFF_BASE = 60;
     BACKOFF_CAP = 900;
-    FAILURE_SUSPECT = 2;
-    FAILURE_DOWN = 3;
     PeerDiscovery = class {
       _selfIp;
       _peers = /* @__PURE__ */ new Map();
@@ -3803,10 +3830,10 @@ var init_peer_discovery = __esm({
       getPeerForAgent(agentId) {
         return this._remoteAgents.get(agentId)?.sourcePeerIp;
       }
-      /** Return true if the peer is in a serving state. */
+      /** Return true if the peer is alive. */
       isPeerReachable(peerIp) {
         const ps = this._peers.get(peerIp);
-        return ps !== void 0 && (ps.status === PARTY_SERVER || ps.status === DEGRADED || ps.status === SUSPECT);
+        return ps !== void 0 && ps.status === ALIVE;
       }
       /** Return all remote agents (including unreachable ones). */
       getAllRemoteAgents() {
@@ -3816,7 +3843,7 @@ var init_peer_discovery = __esm({
       getReachableRemoteAgents() {
         return Array.from(this._remoteAgents.values()).filter((e) => e.reachable).map((e) => e.agentInfo);
       }
-      /** Return all known peer states for dashboard consumption. */
+      /** Return all known peer states. */
       getPeerStates() {
         return Array.from(this._peers.values()).map((ps) => ({
           ip: ps.ip,
@@ -3852,23 +3879,19 @@ var init_peer_discovery = __esm({
         const peerIps = this.getTailscalePeers();
         for (const ip of peerIps) {
           if (!this._peers.has(ip)) {
-            this._peers.set(ip, { ip, status: UNKNOWN, consecutiveFailures: 0, lastProbeAt: 0, backoffUntil: null, maybeRetries: 0 });
+            this._peers.set(ip, { ip, status: UNKNOWN, consecutiveFailures: 0, lastProbeAt: 0, backoffUntil: null });
           }
         }
         const now = performance.now() / 1e3;
         for (const ip of peerIps) {
           const ps = this._peers.get(ip);
-          if (ps.status === NOT_SERVER) {
+          if (ps.status === DEAD) {
             if (ps.backoffUntil !== null && now < ps.backoffUntil) continue;
             ps.status = UNKNOWN;
           }
-          if (ps.status === MAYBE && ps.maybeRetries >= MAYBE_MAX_RETRIES) {
-            this.transition(ps, NOT_SERVER);
-            continue;
-          }
           await this.probePeer(ps);
         }
-        this.evictDownAgents();
+        this.evictDeadAgents();
         this.evictStaleAgents();
       }
       // ------------------------------------------------------------------
@@ -3906,12 +3929,10 @@ var init_peer_discovery = __esm({
       async probePeer(ps) {
         ps.lastProbeAt = Date.now() / 1e3;
         const healthy = await this.checkHealth(ps.ip);
-        if (healthy === null) {
-          this.handleProbeFailure(ps, true);
-        } else if (healthy) {
+        if (healthy === true) {
           await this.handleProbeSuccess(ps);
-        } else {
-          this.handleProbeFailure(ps, false);
+        } else if (healthy === false) {
+          this.handleProbeFailure(ps);
         }
       }
       async checkHealth(ip) {
@@ -3932,55 +3953,24 @@ var init_peer_discovery = __esm({
       // ------------------------------------------------------------------
       async handleProbeSuccess(ps) {
         ps.consecutiveFailures = 0;
-        ps.maybeRetries = 0;
         ps.backoffUntil = null;
-        if (ps.status !== PARTY_SERVER) {
-          this.transition(ps, PARTY_SERVER);
+        if (ps.status !== ALIVE) {
+          const old = ps.status;
+          ps.status = ALIVE;
+          logger.info("Discovery", `Peer ${ps.ip}: ${old} -> ALIVE`);
         }
         await this.syncAgents(ps.ip);
       }
-      handleProbeFailure(ps, timeout) {
-        if (ps.status === UNKNOWN || ps.status === MAYBE) {
-          if (timeout) {
-            ps.maybeRetries++;
-            if (ps.maybeRetries >= MAYBE_MAX_RETRIES) {
-              this.transition(ps, NOT_SERVER);
-            } else {
-              this.transition(ps, MAYBE);
-            }
-          } else {
-            this.transition(ps, NOT_SERVER);
-          }
-        } else if (ps.status === PARTY_SERVER) {
-          ps.consecutiveFailures++;
-          if (ps.consecutiveFailures >= FAILURE_DOWN) {
-            this.transition(ps, DOWN);
-          } else if (ps.consecutiveFailures >= FAILURE_SUSPECT) {
-            this.transition(ps, SUSPECT);
-          } else {
-            this.transition(ps, DEGRADED);
+      handleProbeFailure(ps) {
+        ps.consecutiveFailures++;
+        if (ps.consecutiveFailures >= MAX_FAILURES) {
+          const old = ps.status;
+          ps.status = DEAD;
+          if (old !== DEAD) {
+            const delay = Math.min(BACKOFF_BASE * Math.pow(2, ps.consecutiveFailures - 1), BACKOFF_CAP);
+            ps.backoffUntil = performance.now() / 1e3 + delay;
+            logger.info("Discovery", `Peer ${ps.ip}: ${old} -> DEAD (backoff ${delay}s)`);
           }
-        } else if (ps.status === DEGRADED || ps.status === SUSPECT) {
-          ps.consecutiveFailures++;
-          if (ps.consecutiveFailures >= FAILURE_DOWN) {
-            this.transition(ps, DOWN);
-          } else if (ps.status === DEGRADED && ps.consecutiveFailures >= FAILURE_SUSPECT) {
-            this.transition(ps, SUSPECT);
-          }
-        }
-      }
-      transition(ps, newStatus) {
-        const old = ps.status;
-        ps.status = newStatus;
-        if (old !== newStatus) {
-          logger.info("Discovery", `Peer ${ps.ip}: ${old} -> ${newStatus}`);
-        }
-        if (newStatus === NOT_SERVER) {
-          const retries = ps.maybeRetries > 0 ? ps.maybeRetries : 1;
-          const delay = Math.min(BACKOFF_BASE * Math.pow(2, retries - 1), BACKOFF_CAP);
-          ps.backoffUntil = performance.now() / 1e3 + delay;
-        }
-        if (newStatus === DOWN) {
           for (const entry of this._remoteAgents.values()) {
             if (entry.sourcePeerIp === ps.ip) {
               entry.reachable = false;
@@ -4023,14 +4013,14 @@ var init_peer_discovery = __esm({
       // ------------------------------------------------------------------
       // Cleanup
       // ------------------------------------------------------------------
-      evictDownAgents() {
-        const downPeers = /* @__PURE__ */ new Set();
+      evictDeadAgents() {
+        const deadPeers = /* @__PURE__ */ new Set();
         for (const [ip, ps] of this._peers) {
-          if (ps.status === DOWN) downPeers.add(ip);
+          if (ps.status === DEAD) deadPeers.add(ip);
         }
-        if (!downPeers.size) return;
+        if (!deadPeers.size) return;
         for (const [aid, entry] of this._remoteAgents) {
-          if (downPeers.has(entry.sourcePeerIp)) {
+          if (deadPeers.has(entry.sourcePeerIp)) {
             this._remoteAgents.delete(aid);
           }
         }
@@ -4053,8 +4043,10 @@ var AgentRegistry;
 var init_registry = __esm({
   "src/server/registry.ts"() {
     "use strict";
+    init_config();
     AgentRegistry = class {
       _agents = /* @__PURE__ */ new Map();
+      _staleCounts = /* @__PURE__ */ new Map();
       _selfIp;
       constructor(selfIp) {
         this._selfIp = selfIp;
@@ -4067,19 +4059,23 @@ var init_registry = __esm({
           host_ip: this._selfIp,
           registered_at: now,
           last_heartbeat: now,
-          metadata: req.metadata ?? {}
+          metadata: req.metadata ?? {},
+          callback_url: req.callback_url
         };
         this._agents.set(req.agent_id, info);
+        this._staleCounts.set(req.agent_id, 0);
         return info;
       }
       remove(agentId) {
         const existed = this._agents.delete(agentId);
+        this._staleCounts.delete(agentId);
         return existed;
       }
       heartbeat(agentId) {
         const info = this._agents.get(agentId);
         if (!info) throw new Error(`Agent '${agentId}' not registered`);
         info.last_heartbeat = Date.now() / 1e3;
+        this._staleCounts.set(agentId, 0);
         return info;
       }
       get(agentId) {
@@ -4088,19 +4084,30 @@ var init_registry = __esm({
       listAll() {
         return Array.from(this._agents.values());
       }
-      /** Remove agents whose last heartbeat is older than timeout seconds. */
+      /** Remove agents whose last heartbeat is older than timeout seconds.
+       *  Uses a stale counter: an agent must exceed the timeout STALE_THRESHOLD
+       *  consecutive times before being actually removed. Any heartbeat resets
+       *  the counter to zero, giving transient network issues room to recover.
+       */
       cleanupStale(timeout) {
         const now = Date.now() / 1e3;
-        const stale = [];
+        const toRemove = [];
         for (const [aid, info] of this._agents) {
           if (now - info.last_heartbeat > timeout) {
-            stale.push(aid);
+            const count = (this._staleCounts.get(aid) ?? 0) + 1;
+            this._staleCounts.set(aid, count);
+            if (count >= STALE_THRESHOLD) {
+              toRemove.push(aid);
+            }
+          } else {
+            this._staleCounts.set(aid, 0);
           }
         }
-        for (const aid of stale) {
+        for (const aid of toRemove) {
           this._agents.delete(aid);
+          this._staleCounts.delete(aid);
         }
-        return stale;
+        return toRemove;
       }
     };
   }
@@ -4118,7 +4125,6 @@ __export(state_exports, {
   messageQueue: () => messageQueue,
   refreshSelfIp: () => refreshSelfIp,
   registry: () => registry,
-  scheduleSnapshot: () => scheduleSnapshot,
   snapshotManager: () => snapshotManager
 });
 function resolveSelfIp() {
@@ -4139,12 +4145,6 @@ function refreshSelfIp() {
   _selfIp = resolveSelfIp();
   return _selfIp;
 }
-function scheduleSnapshot() {
-  snapshotManager?.scheduleSnapshot(
-    () => registry.listAll(),
-    () => messageQueue.getHistorySnapshot()
-  );
-}
 function initSnapshotManager(mgr) {
   snapshotManager = mgr;
 }
@@ -4183,12 +4183,38 @@ var init_models = __esm({
   }
 });
 
+// src/server/callback.ts
+function postCallback(callbackUrl, payload) {
+  fetch(callbackUrl, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(payload),
+    signal: AbortSignal.timeout(CALLBACK_TIMEOUT_MS)
+  }).then((resp) => {
+    if (!resp.ok) {
+      logger.warn("Webhook", `Callback HTTP error: url=${callbackUrl}, status=${resp.status}`);
+    }
+  }).catch((err) => {
+    logger.warn("Webhook", `Callback failed: url=${callbackUrl}, error=${err.message}`);
+  });
+}
+var CALLBACK_TIMEOUT_MS;
+var init_callback = __esm({
+  "src/server/callback.ts"() {
+    "use strict";
+    init_logger();
+    CALLBACK_TIMEOUT_MS = 5e3;
+  }
+});
+
 // src/server/routes/agent.ts
 async function forwardToPeer(peerIp, envelope) {
   const url = `http://${peerIp}:${PARTY_PORT}/proxy/receive`;
   const payload = { sender_id: envelope.sender_id, content: envelope.content };
   if (envelope.recipient_id) payload.recipient_id = envelope.recipient_id;
   if (envelope.group_id) payload.group_id = envelope.group_id;
+  if (envelope.summary) payload.summary = envelope.summary;
+  if (envelope.timestamp) payload.timestamp = envelope.timestamp;
   try {
     await fetch(url, {
       method: "POST",
@@ -4208,28 +4234,49 @@ var init_agent = __esm({
     init_models();
     init_config();
     init_logger();
+    init_callback();
     agentRoutes = new Hono2();
     agentRoutes.post("/register", async (c) => {
-      const { registry: registry2, scheduleSnapshot: scheduleSnapshot3 } = await Promise.resolve().then(() => (init_state(), state_exports));
+      const { registry: registry2 } = await Promise.resolve().then(() => (init_state(), state_exports));
       const req = await c.req.json();
       const info = registry2.register(req);
-      scheduleSnapshot3();
-      logger.info("Agent", `Registered: ${info.agent_id} (display: "${info.display_name ?? "N/A"}")`);
+      logger.info("Agent", `Registered: ${info.agent_id} (display: "${info.display_name ?? "N/A"}", callback=${info.callback_url ?? "none"})`);
       return c.json(sanitizeAgentInfo(info));
     });
     agentRoutes.post("/remove", async (c) => {
-      const { registry: registry2, scheduleSnapshot: scheduleSnapshot3 } = await Promise.resolve().then(() => (init_state(), state_exports));
+      const { registry: registry2, messageQueue: messageQueue2 } = await Promise.resolve().then(() => (init_state(), state_exports));
       const req = await c.req.json();
       const removed = registry2.remove(req.agent_id);
-      if (removed) scheduleSnapshot3();
+      if (removed) {
+        messageQueue2.removeAgent(req.agent_id);
+        messageQueue2.removeAgentHistory(req.agent_id);
+      }
       logger.info("Agent", removed ? `Removed: ${req.agent_id}` : `Remove failed: ${req.agent_id} (not found)`);
       return c.json({ status: removed ? "removed" : "not_found" });
     });
     agentRoutes.post("/heartbeat", async (c) => {
       const { registry: registry2 } = await Promise.resolve().then(() => (init_state(), state_exports));
       const req = await c.req.json();
-      const info = registry2.heartbeat(req.agent_id);
-      logger.info("Agent", `Heartbeat from ${req.agent_id}`);
+      let info;
+      try {
+        info = registry2.heartbeat(req.agent_id);
+        if (req.callback_url) {
+          info.callback_url = req.callback_url;
+        }
+      } catch (err) {
+        if (err instanceof Error && err.message.includes("not registered")) {
+          info = registry2.register({
+            agent_id: req.agent_id,
+            display_name: req.display_name,
+            metadata: req.metadata,
+            callback_url: req.callback_url
+          });
+          logger.info("Agent", `Auto-re-registered: ${req.agent_id} (was cleaned up)`);
+        } else {
+          throw err;
+        }
+      }
+      logger.info("Agent", `Heartbeat from ${req.agent_id}${req.callback_url ? `, callback=${req.callback_url}` : ""}`);
       return c.json({ status: "ok", last_heartbeat: info.last_heartbeat });
     });
     agentRoutes.get("/list", async (c) => {
@@ -4240,18 +4287,31 @@ var init_agent = __esm({
       return c.json({ agents: sanitizeAgentList(allAgents), count: allAgents.length });
     });
     agentRoutes.post("/send", async (c) => {
-      const { registry: registry2, messageQueue: messageQueue2, discovery: discovery2, scheduleSnapshot: scheduleSnapshot3 } = await Promise.resolve().then(() => (init_state(), state_exports));
+      const { registry: registry2, messageQueue: messageQueue2, discovery: discovery2 } = await Promise.resolve().then(() => (init_state(), state_exports));
       const envelope = await c.req.json();
       const recipient = envelope.recipient_id;
       if (!recipient) {
         return c.json({ status: "error", error: "recipient_id is required" });
       }
-      if (registry2.get(recipient)) {
+      const recipientInfo = registry2.get(recipient);
+      if (recipientInfo) {
         const stamped = { ...envelope, timestamp: envelope.timestamp ?? Date.now() / 1e3 };
         const count = messageQueue2.enqueue(recipient, stamped);
         messageQueue2.logToHistory(envelope.sender_id, "sent", stamped);
-        messageQueue2.logToHistory(recipient, "received", stamped);
-        scheduleSnapshot3();
+        if (recipientInfo.callback_url) {
+          const callbackPayload = {
+            type: "message_received",
+            recipient_id: recipient,
+            sender_id: envelope.sender_id,
+            summary: envelope.summary,
+            timestamp: stamped.timestamp,
+            pending_count: count
+          };
+          logger.info("Webhook", `Callback: agent=${recipient}, url=${recipientInfo.callback_url}, sender=${envelope.sender_id}`);
+          postCallback(recipientInfo.callback_url, callbackPayload);
+        } else {
+          logger.debug("Webhook", `No callback_url for agent=${recipient}, skipping webhook`);
+        }
         logger.info("Agent", `Send ${envelope.sender_id} -> ${recipient}: delivered_locally`);
         return c.json({ status: "delivered_locally", target: recipient });
       }
@@ -4261,7 +4321,6 @@ var init_agent = __esm({
           const result = await forwardToPeer(peerIp, envelope);
           if (result.status === "forwarded") {
             messageQueue2.logToHistory(envelope.sender_id, "sent", { ...envelope, timestamp: envelope.timestamp ?? Date.now() / 1e3 });
-            scheduleSnapshot3();
             logger.info("Agent", `Send ${envelope.sender_id} -> ${recipient}: forwarded (peer ${peerIp})`);
           }
           return c.json(result);
@@ -4300,6 +4359,7 @@ var init_proxy = __esm({
     init_tailscale();
     init_state();
     init_logger();
+    init_callback();
     proxyRoutes = new Hono2();
     proxyRoutes.get("/health", async (c) => {
       let hostname = "127.0.0.1";
@@ -4322,9 +4382,22 @@ var init_proxy = __esm({
       const envelope = await c.req.json();
       const stamped = { ...envelope, timestamp: envelope.timestamp ?? Date.now() / 1e3 };
       if (envelope.recipient_id) {
-        messageQueue.enqueue(envelope.recipient_id, stamped);
+        const count = messageQueue.enqueue(envelope.recipient_id, stamped);
         messageQueue.logToHistory(envelope.recipient_id, "received", stamped);
         logger.info("Proxy", `Received msg ${envelope.sender_id} -> ${envelope.recipient_id}`);
+        const recipientInfo = registry.get(envelope.recipient_id);
+        if (recipientInfo?.callback_url) {
+          const callbackPayload = {
+            type: "message_received",
+            recipient_id: envelope.recipient_id,
+            sender_id: envelope.sender_id,
+            summary: envelope.summary,
+            timestamp: stamped.timestamp,
+            pending_count: count
+          };
+          logger.info("Webhook", `Proxy callback: agent=${envelope.recipient_id}, url=${recipientInfo.callback_url}, sender=${envelope.sender_id}`);
+          postCallback(recipientInfo.callback_url, callbackPayload);
+        }
       } else {
         for (const agent of registry.listAll()) {
           messageQueue.enqueue(agent.agent_id, stamped);
@@ -4358,1298 +4431,68 @@ var init_proxy = __esm({
   }
 });
 
-// src/server/dashboard-html.ts
-var DASHBOARD_HTML;
-var init_dashboard_html = __esm({
-  "src/server/dashboard-html.ts"() {
-    "use strict";
-    DASHBOARD_HTML = `<!DOCTYPE html>
-<html lang="zh-CN">
-<head>
-<meta charset="UTF-8">
-<meta name="viewport" content="width=device-width, initial-scale=1.0">
-<title>OPEN PARTY // Dashboard</title>
-<style>
-*,*::before,*::after{box-sizing:border-box;margin:0;padding:0}
-:root{
-  --bg:#0a0a0f;--card:#12121a;--border:#1e1e2e;--border-bright:#2a2a3e;
-  --text:#e0e0e8;--muted:#6a6a8a;
-  --cyan:#00fff0;--magenta:#ff00ff;--green:#00ff88;--red:#ff3366;--yellow:#ffaa00;--orange:#ff8800;
-  --font-mono:'JetBrains Mono','Fira Code','Cascadia Code','Consolas','Courier New',monospace;
-  --font-sans:'Inter','Segoe UI',system-ui,-apple-system,sans-serif;
-}
-html{font-size:14px}
-body{
-  background:var(--bg);color:var(--text);font-family:var(--font-sans);
-  min-height:100vh;overflow-x:hidden;position:relative;
-}
-/* Grid background */
-body::before{
-  content:'';position:fixed;inset:0;z-index:0;pointer-events:none;
-  background-image:
-    linear-gradient(rgba(0,255,240,0.03) 1px,transparent 1px),
-    linear-gradient(90deg,rgba(0,255,240,0.03) 1px,transparent 1px);
-  background-size:40px 40px;
-}
-/* Scanline overlay */
-body::after{
-  content:'';position:fixed;inset:0;z-index:9999;pointer-events:none;
-  background:repeating-linear-gradient(
-    0deg,transparent,transparent 2px,rgba(0,0,0,0.08) 2px,rgba(0,0,0,0.08) 4px
-  );
-}
-#app{position:relative;z-index:1;max-width:1400px;margin:0 auto;padding:0 20px 40px}
-
-/* ===== Header ===== */
-.header{
-  display:flex;align-items:center;justify-content:space-between;
-  padding:16px 0;border-bottom:1px solid var(--border);
-  margin-bottom:20px;flex-wrap:wrap;gap:12px;
-}
-.header-title{
-  font-family:var(--font-mono);font-size:1.4rem;font-weight:700;
-  color:var(--cyan);letter-spacing:3px;
-  text-shadow:0 0 10px rgba(0,255,240,0.5),0 0 30px rgba(0,255,240,0.2);
-}
-.header-title span{color:var(--muted);font-weight:400;font-size:0.9rem;margin-left:8px;letter-spacing:1px}
-.header-center{display:flex;align-items:center;gap:16px;flex-wrap:wrap}
-.header-status{display:flex;align-items:center;gap:6px;font-family:var(--font-mono);font-size:0.85rem}
-.status-dot{
-  width:8px;height:8px;border-radius:50%;background:var(--green);
-  box-shadow:0 0 6px var(--green);animation:pulse 2s ease-in-out infinite;
-}
-.status-dot.offline{background:var(--red);box-shadow:0 0 6px var(--red)}
-.status-dot.not-installed{background:var(--red);box-shadow:0 0 6px var(--red)}
-.status-dot.not-connected{background:var(--yellow);box-shadow:0 0 6px var(--yellow)}
-@keyframes pulse{0%,100%{opacity:1;transform:scale(1)}50%{opacity:0.5;transform:scale(0.8)}}
-.header-meta{color:var(--muted);font-family:var(--font-mono);font-size:0.8rem}
-.header-right{font-family:var(--font-mono);font-size:0.85rem;color:var(--muted)}
-.header-right .value{color:var(--cyan)}
-
-/* ===== Stats Cards ===== */
-.stats-row{display:grid;grid-template-columns:repeat(4,1fr);gap:16px;margin-bottom:24px}
-@media(max-width:768px){.stats-row{grid-template-columns:repeat(2,1fr)}}
-.stat-card{
-  background:var(--card);border:1px solid var(--border);border-radius:8px;
-  padding:16px 20px;position:relative;overflow:hidden;
-  transition:border-color 0.3s;
-}
-.stat-card:hover{border-color:var(--border-bright)}
-.stat-card::before{
-  content:'';position:absolute;top:0;left:0;right:0;height:2px;
-}
-.stat-card.cyan::before{background:var(--cyan);box-shadow:0 0 10px var(--cyan)}
-.stat-card.green::before{background:var(--green);box-shadow:0 0 10px var(--green)}
-.stat-card.magenta::before{background:var(--magenta);box-shadow:0 0 10px var(--magenta)}
-.stat-card.yellow::before{background:var(--yellow);box-shadow:0 0 10px var(--yellow)}
-.stat-value{
-  font-family:var(--font-mono);font-size:2rem;font-weight:700;
-  transition:color 0.3s;
-}
-.stat-card.cyan .stat-value{color:var(--cyan)}
-.stat-card.green .stat-value{color:var(--green)}
-.stat-card.magenta .stat-value{color:var(--magenta)}
-.stat-card.yellow .stat-value{color:var(--yellow)}
-.stat-label{color:var(--muted);font-size:0.8rem;margin-top:4px;text-transform:uppercase;letter-spacing:1px}
-.stat-value.flash{animation:flash 0.3s ease}
-@keyframes flash{0%{opacity:1}50%{opacity:0.3}100%{opacity:1}}
-
-/* ===== Main Grid ===== */
-.main-grid{display:grid;grid-template-columns:2fr 1fr;gap:20px;margin-bottom:24px}
-@media(max-width:1024px){.main-grid{grid-template-columns:1fr}}
-.section{
-  background:var(--card);border:1px solid var(--border);border-radius:8px;
-  overflow:hidden;
-}
-.section-header{
-  padding:12px 16px;border-bottom:1px solid var(--border);
-  font-family:var(--font-mono);font-size:0.8rem;font-weight:600;
-  color:var(--muted);letter-spacing:2px;text-transform:uppercase;
-  display:flex;align-items:center;gap:8px;
-}
-.section-header .dot{width:6px;height:6px;border-radius:50%;background:var(--cyan)}
-.section-body{padding:16px}
-
-/* ===== Topology ===== */
-.topology-container{display:flex;justify-content:center;align-items:center;min-height:300px}
-.topology-container svg{width:100%;max-width:500px;height:300px}
-.topo-node{cursor:pointer;transition:filter 0.3s}
-.topo-node:hover{filter:brightness(1.3)}
-.topo-label{font-family:var(--font-mono);font-size:10px;fill:var(--muted)}
-.topo-badge{
-  font-family:var(--font-mono);font-size:9px;fill:var(--bg);
-  font-weight:700;
-}
-
-/* ===== Peer Table ===== */
-.peer-table{width:100%;border-collapse:collapse;font-size:0.85rem}
-.peer-table th{
-  text-align:left;padding:8px 10px;color:var(--muted);font-weight:600;
-  font-family:var(--font-mono);font-size:0.75rem;text-transform:uppercase;
-  letter-spacing:1px;border-bottom:1px solid var(--border);
+// src/server/index.ts
+var server_exports = {};
+import { mkdirSync as mkdirSync5, writeFileSync as writeFileSync4, unlinkSync as unlinkSync4 } from "fs";
+import { join as join6, dirname as dirname4 } from "path";
+import { homedir as homedir5 } from "os";
+async function periodicCleanup() {
+  while (!lifecycleController.signal.aborted) {
+    try {
+      const removed = registry.cleanupStale(HEARTBEAT_TIMEOUT);
+      if (removed.length > 0) {
+        logger.info("Cleanup", `Removed ${removed.length} stale agent(s): ${removed.join(", ")}`);
+        for (const aid of removed) {
+          messageQueue.removeAgent(aid);
+          messageQueue.removeAgentHistory(aid);
+        }
+      }
+    } catch (e) {
+      logger.error("Cleanup", "Error during cleanup", e);
+    }
+    await abortableSleep(CLEANUP_INTERVAL * 1e3, lifecycleController.signal);
+  }
 }
-.peer-table td{padding:8px 10px;border-bottom:1px solid var(--border);font-family:var(--font-mono);font-size:0.8rem}
-.peer-table tr:last-child td{border-bottom:none}
-.peer-table tr:hover td{background:rgba(255,255,255,0.02)}
-.badge{
-  display:inline-block;padding:2px 8px;border-radius:4px;font-size:0.7rem;
-  font-weight:600;text-transform:uppercase;letter-spacing:0.5px;
+function pidFilePath2() {
+  const pluginData = process.env.CLAUDE_PLUGIN_DATA || "";
+  if (pluginData) return join6(pluginData, "server.pid");
+  return join6(homedir5(), ".open-party", "server.pid");
 }
-.badge-party{background:rgba(0,255,136,0.15);color:var(--green)}
-.badge-degraded{background:rgba(255,170,0,0.15);color:var(--yellow)}
-.badge-suspect{background:rgba(255,136,0,0.15);color:var(--orange)}
-.badge-down{background:rgba(255,51,102,0.15);color:var(--red)}
-.badge-unknown{background:rgba(106,106,138,0.15);color:var(--muted)}
-.badge-not_server{background:rgba(106,106,138,0.1);color:var(--muted)}
-.badge-maybe{background:rgba(0,255,240,0.1);color:var(--cyan)}
-.empty-state{text-align:center;color:var(--muted);padding:40px 20px;font-family:var(--font-mono);font-size:0.85rem}
-
-/* ===== Agent & Message Grid ===== */
-.bottom-grid{display:grid;grid-template-columns:1fr 1fr;gap:20px;margin-bottom:24px}
-@media(max-width:1024px){.bottom-grid{grid-template-columns:1fr}}
-
-/* Agent cards */
-.agent-list{display:flex;flex-direction:column;gap:8px;max-height:400px;overflow-y:auto}
-.agent-card{
-  display:flex;align-items:center;gap:12px;padding:10px 14px;
-  border:1px solid var(--border);border-radius:6px;transition:border-color 0.3s;
-}
-.agent-card:hover{border-color:var(--border-bright)}
-.agent-card.local{border-left:3px solid var(--cyan)}
-.agent-card.remote{border-left:3px solid var(--green)}
-.agent-icon{
-  width:36px;height:36px;border-radius:6px;display:flex;align-items:center;
-  justify-content:center;font-family:var(--font-mono);font-size:0.9rem;font-weight:700;
-  flex-shrink:0;
-}
-.agent-card.local .agent-icon{background:rgba(0,255,240,0.1);color:var(--cyan)}
-.agent-card.remote .agent-icon{background:rgba(0,255,136,0.1);color:var(--green)}
-.agent-info{flex:1;min-width:0}
-.agent-name{font-weight:600;font-size:0.9rem;white-space:nowrap;overflow:hidden;text-overflow:ellipsis}
-.agent-id{font-family:var(--font-mono);font-size:0.7rem;color:var(--muted);margin-top:2px}
-.agent-meta{display:flex;gap:6px;flex-shrink:0;align-items:center}
-.agent-tag{
-  font-family:var(--font-mono);font-size:0.65rem;padding:2px 6px;
-  border-radius:3px;background:rgba(255,255,255,0.05);color:var(--muted);
-}
-.agent-tag.unreachable{background:rgba(255,51,102,0.1);color:var(--red)}
-
-/* Message feed */
-.msg-feed{display:flex;flex-direction:column;gap:6px;max-height:400px;overflow-y:auto}
-.msg-item{
-  padding:10px 12px;border:1px solid var(--border);border-radius:6px;
-  border-left:3px solid var(--cyan);font-size:0.8rem;
-}
-.msg-item.received{border-left-color:var(--magenta)}
-.msg-top{display:flex;justify-content:space-between;align-items:center;margin-bottom:4px}
-.msg-flow{font-family:var(--font-mono);font-size:0.75rem;color:var(--cyan)}
-.msg-flow .arrow{color:var(--muted);margin:0 4px}
-.msg-time{font-family:var(--font-mono);font-size:0.65rem;color:var(--muted)}
-.msg-content{color:var(--text);font-size:0.8rem;line-height:1.4;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}
-
-/* Scrollbar */
-::-webkit-scrollbar{width:4px}
-::-webkit-scrollbar-track{background:var(--bg)}
-::-webkit-scrollbar-thumb{background:var(--border);border-radius:2px}
-::-webkit-scrollbar-thumb:hover{background:var(--border-bright)}
-
-/* Footer */
-.footer{
-  text-align:center;padding:20px 0;border-top:1px solid var(--border);
-  color:var(--muted);font-family:var(--font-mono);font-size:0.75rem;
-  letter-spacing:1px;
-}
-
-/* Join Network Button */
-.btn-join{
-  font-family:var(--font-mono);font-size:0.75rem;letter-spacing:1px;
-  padding:6px 14px;border:1px solid var(--cyan);border-radius:4px;
-  background:rgba(0,255,240,0.08);color:var(--cyan);cursor:pointer;
-  transition:all 0.2s;text-transform:uppercase;margin-left:12px;
-}
-.btn-join:hover{background:rgba(0,255,240,0.18);box-shadow:0 0 10px rgba(0,255,240,0.2)}
-.btn-join:active{transform:scale(0.97)}
-.btn-logout{border-color:var(--red);color:var(--red);background:rgba(255,51,102,0.08)}
-.btn-logout:hover{background:rgba(255,51,102,0.18);box-shadow:0 0 10px rgba(255,51,102,0.2)}
-.btn-install{border-color:var(--yellow);color:var(--yellow);background:rgba(255,170,0,0.08)}
-.btn-install:hover{background:rgba(255,170,0,0.18);box-shadow:0 0 10px rgba(255,170,0,0.2)}
-
-/* Tab bar inside modal */
-.tab-bar{display:flex;gap:0;margin-bottom:18px;border-bottom:1px solid var(--border)}
-.tab-bar .tab{
-  font-family:var(--font-mono);font-size:0.8rem;padding:8px 16px;cursor:pointer;
-  color:var(--muted);border-bottom:2px solid transparent;transition:all 0.2s;
-}
-.tab-bar .tab:hover{color:var(--text)}
-.tab-bar .tab.active{color:var(--cyan);border-bottom-color:var(--cyan)}
-.tab-content{display:none}
-.tab-content.active{display:block}
-
-/* Modal */
-.modal-overlay{
-  position:fixed;inset:0;background:rgba(0,0,0,0.7);z-index:10000;
-  display:flex;align-items:center;justify-content:center;
-  opacity:0;pointer-events:none;transition:opacity 0.25s;
-}
-.modal-overlay.open{opacity:1;pointer-events:all}
-.modal{
-  background:var(--card);border:1px solid var(--border-bright);border-radius:10px;
-  padding:28px 32px;width:90%;max-width:440px;
-  box-shadow:0 0 40px rgba(0,255,240,0.08),0 8px 32px rgba(0,0,0,0.5);
-}
-.modal-title{
-  font-family:var(--font-mono);font-size:1rem;font-weight:700;color:var(--cyan);
-  letter-spacing:2px;margin-bottom:6px;
-  text-shadow:0 0 8px rgba(0,255,240,0.3);
-}
-.modal-desc{color:var(--muted);font-size:0.8rem;margin-bottom:20px;line-height:1.5}
-.modal-input{
-  width:100%;padding:10px 14px;background:var(--bg);border:1px solid var(--border);
-  border-radius:6px;color:var(--text);font-family:var(--font-mono);font-size:0.85rem;
-  outline:none;transition:border-color 0.2s;
-}
-.modal-input:focus{border-color:var(--cyan);box-shadow:0 0 8px rgba(0,255,240,0.15)}
-.modal-input::placeholder{color:var(--muted)}
-.modal-actions{display:flex;gap:10px;margin-top:18px;justify-content:flex-end}
-.modal-btn{
-  font-family:var(--font-mono);font-size:0.8rem;padding:8px 18px;
-  border-radius:4px;cursor:pointer;transition:all 0.2s;letter-spacing:0.5px;
-}
-.modal-btn-cancel{
-  border:1px solid var(--border);background:transparent;color:var(--muted);
-}
-.modal-btn-cancel:hover{border-color:var(--muted);color:var(--text)}
-.modal-btn-submit{
-  border:1px solid var(--cyan);background:rgba(0,255,240,0.12);color:var(--cyan);
-}
-.modal-btn-submit:hover{background:rgba(0,255,240,0.22);box-shadow:0 0 10px rgba(0,255,240,0.2)}
-.modal-btn-submit:disabled{opacity:0.4;cursor:not-allowed}
-.modal-status{
-  margin-top:12px;padding:8px 12px;border-radius:4px;font-size:0.78rem;
-  font-family:var(--font-mono);display:none;
-}
-.modal-status.success{display:block;background:rgba(0,255,136,0.1);border:1px solid rgba(0,255,136,0.3);color:var(--green)}
-.modal-status.error{display:block;background:rgba(255,51,102,0.1);border:1px solid rgba(255,51,102,0.3);color:var(--red)}
-.spinner{
-  display:inline-block;width:12px;height:12px;border:2px solid transparent;
-  border-top-color:var(--cyan);border-radius:50%;animation:spin 0.6s linear infinite;
-  vertical-align:middle;margin-right:6px;
-}
-@keyframes spin{to{transform:rotate(360deg)}}
-
-/* ===== Tailscale Status Panel ===== */
-.ts-panel{
-  margin-top:12px;padding:16px 20px;background:var(--card);border:1px solid var(--border);
-  border-radius:8px;font-family:var(--font-mono);font-size:0.8rem;
-}
-.ts-panel-title{
-  font-weight:700;letter-spacing:2px;text-transform:uppercase;margin-bottom:10px;
-  display:flex;align-items:center;gap:8px;
-}
-.ts-panel-title.connected{color:var(--green)}
-.ts-panel-title.not-installed{color:var(--red)}
-.ts-panel-title.not-connected{color:var(--yellow)}
-.ts-info-row{display:flex;gap:8px;margin:4px 0;color:var(--muted)}
-.ts-info-row .label{min-width:100px;color:var(--muted)}
-.ts-info-row .value{color:var(--text)}
-.ts-install-guide{
-  margin-top:12px;padding:12px 16px;background:rgba(0,0,0,0.3);border:1px solid var(--border);
-  border-radius:6px;
-}
-.ts-install-guide .cmd{
-  display:flex;align-items:center;justify-content:space-between;
-  padding:6px 10px;background:rgba(255,255,255,0.04);border-radius:4px;
-  margin:6px 0;font-size:0.8rem;cursor:pointer;transition:background 0.2s;
-}
-.ts-install-guide .cmd:hover{background:rgba(255,255,255,0.08)}
-.ts-install-guide .cmd code{color:var(--cyan)}
-.ts-install-guide .copy-hint{color:var(--muted);font-size:0.7rem}
-.ts-install-guide a{color:var(--cyan);text-decoration:none}
-.ts-install-guide a:hover{text-decoration:underline}
-.ts-setup-hint{
-  margin-top:10px;padding:8px 12px;background:rgba(0,255,240,0.05);border:1px solid rgba(0,255,240,0.15);
-  border-radius:4px;color:var(--cyan);font-size:0.78rem;
-}
-.btn-redetect{
-  font-family:var(--font-mono);font-size:0.7rem;padding:4px 12px;
-  border:1px solid var(--border-bright);border-radius:4px;background:transparent;
-  color:var(--muted);cursor:pointer;transition:all 0.2s;margin-top:8px;
-}
-.btn-redetect:hover{border-color:var(--cyan);color:var(--cyan)}
-</style>
-</head>
-<body>
-<div id="app">
-  <header class="header">
-    <div class="header-title">OPEN PARTY<span>// Dashboard</span></div>
-    <div class="header-center">
-      <div class="header-status">
-        <div class="status-dot" id="statusDot"></div>
-        <span id="statusText">CONNECTING</span>
-      </div>
-      <div class="header-meta" id="serverInfo">--</div>
-    </div>
-    <div class="header-right">
-      UPTIME <span class="value" id="uptime">--:--:--</span>
-      <button class="btn-join" id="btnJoinNetwork" title="Join Tailscale Network">Join Network</button>
-    </div>
-  </header>
-
-  <!-- Tailscale status panel (shown when not connected) -->
-  <div id="tsPanel" class="ts-panel" style="display:none"></div>
-
-  <div class="stats-row" id="statsRow">
-    <div class="stat-card cyan">
-      <div class="stat-value" id="localAgentCount">-</div>
-      <div class="stat-label">Local Agents</div>
-    </div>
-    <div class="stat-card green">
-      <div class="stat-value" id="remoteAgentCount">-</div>
-      <div class="stat-label">Remote Agents</div>
-    </div>
-    <div class="stat-card magenta">
-      <div class="stat-value" id="peerCount">-</div>
-      <div class="stat-label">Known Peers</div>
-    </div>
-    <div class="stat-card yellow">
-      <div class="stat-value" id="partyServerCount">-</div>
-      <div class="stat-label">Party Servers</div>
-    </div>
-  </div>
-
-  <div class="main-grid">
-    <div class="section">
-      <div class="section-header"><div class="dot"></div>NETWORK TOPOLOGY</div>
-      <div class="section-body">
-        <div class="topology-container" id="topologyContainer">
-          <svg id="topologySvg" viewBox="0 0 500 300"></svg>
-        </div>
-      </div>
-    </div>
-    <div class="section">
-      <div class="section-header"><div class="dot" style="background:var(--green)"></div>PEER HEALTH</div>
-      <div class="section-body" style="padding:0">
-        <div id="peerTableContainer">
-          <table class="peer-table">
-            <thead><tr><th>IP</th><th>Status</th><th>Fails</th><th>Last Probe</th></tr></thead>
-            <tbody id="peerTableBody"></tbody>
-          </table>
-        </div>
-      </div>
-    </div>
-  </div>
-
-  <div class="bottom-grid">
-    <div class="section">
-      <div class="section-header"><div class="dot" style="background:var(--cyan)"></div>AGENT DIRECTORY</div>
-      <div class="section-body">
-        <div class="agent-list" id="agentList"></div>
-      </div>
-    </div>
-    <div class="section">
-      <div class="section-header"><div class="dot" style="background:var(--magenta)"></div>MESSAGE FLOW</div>
-      <div class="section-body">
-        <div class="msg-feed" id="msgFeed"></div>
-      </div>
-    </div>
-  </div>
-
-  <div class="footer">OPEN PARTY v0.1 // DECENTRALIZED AGENT NETWORK</div>
-
-  <!-- Join Network / Login Modal (two tabs: Interactive + Auth Key) -->
-  <div class="modal-overlay" id="joinModal">
-    <div class="modal">
-      <div class="modal-title">CONNECT TO TAILNET</div>
-      <div class="tab-bar" id="joinTabs">
-        <div class="tab active" data-tab="interactive">Interactive</div>
-        <div class="tab" data-tab="authkey">Auth Key</div>
-      </div>
-
-      <!-- Interactive tab -->
-      <div class="tab-content active" id="tabInteractive">
-        <div class="modal-desc">Click the button below to open a browser authentication page.<br>Your Tailscale connection will be established once you authenticate.</div>
-        <div class="modal-status" id="interactiveStatus"></div>
-        <div class="modal-actions">
-          <button class="modal-btn modal-btn-cancel" id="btnCancelJoin">Cancel</button>
-          <button class="modal-btn modal-btn-submit" id="btnInteractiveLogin">Open Browser Login</button>
-        </div>
-      </div>
-
-      <!-- Auth Key tab -->
-      <div class="tab-content" id="tabAuthkey">
-        <div class="modal-desc">Enter your Tailscale auth key to join the network.<br>You can generate one from the Tailscale admin console.</div>
-        <input type="password" class="modal-input" id="authKeyInput" placeholder="tskey-auth-xxxxx..." autocomplete="off" spellcheck="false" />
-        <div class="modal-status" id="joinStatus"></div>
-        <div class="modal-actions">
-          <button class="modal-btn modal-btn-cancel" id="btnCancelAuthkey">Cancel</button>
-          <button class="modal-btn modal-btn-submit" id="btnSubmitJoin">Connect</button>
-        </div>
-      </div>
-    </div>
-  </div>
-
-  <!-- Logout Confirmation Modal -->
-  <div class="modal-overlay" id="logoutModal">
-    <div class="modal">
-      <div class="modal-title" style="color:var(--red)">LOG OUT OF TAILNET</div>
-      <div class="modal-desc">This will disconnect from Tailscale and remove your credentials.<br>You will need to re-authenticate to reconnect.</div>
-      <div class="modal-status" id="logoutStatus"></div>
-      <div class="modal-actions">
-        <button class="modal-btn modal-btn-cancel" id="btnCancelLogout">Cancel</button>
-        <button class="modal-btn modal-btn-submit" style="border-color:var(--red);color:var(--red);background:rgba(255,51,102,0.12)" id="btnConfirmLogout">Log Out</button>
-      </div>
-    </div>
-  </div>
-</div>
-
-<script>
-(function() {
-  'use strict';
-
-  // ---- Helpers ----
-  const $ = (s) => document.querySelector(s);
-  const $$ = (s) => document.querySelectorAll(s);
-
-  function formatUptime(seconds) {
-    const h = Math.floor(seconds / 3600);
-    const m = Math.floor((seconds % 3600) / 60);
-    const s = seconds % 60;
-    return String(h).padStart(2,'0') + ':' + String(m).padStart(2,'0') + ':' + String(s).padStart(2,'0');
-  }
-
-  function timeAgo(ts) {
-    if (!ts) return '--';
-    const diff = Math.floor(Date.now() / 1000 - ts);
-    if (diff < 0) return 'now';
-    if (diff < 60) return diff + 's ago';
-    if (diff < 3600) return Math.floor(diff / 60) + 'm ago';
-    return Math.floor(diff / 3600) + 'h ago';
-  }
-
-  function flashEl(el) {
-    el.classList.remove('flash');
-    void el.offsetWidth;
-    el.classList.add('flash');
-  }
-
-  const statusColors = {
-    PARTY_SERVER: '#00ff88',
-    DEGRADED: '#ffaa00',
-    SUSPECT: '#ff8800',
-    DOWN: '#ff3366',
-    UNKNOWN: '#6a6a8a',
-    NOT_SERVER: '#6a6a8a',
-    MAYBE: '#00fff0',
-  };
-
-  const statusBadgeClass = {
-    PARTY_SERVER: 'badge-party',
-    DEGRADED: 'badge-degraded',
-    SUSPECT: 'badge-suspect',
-    DOWN: 'badge-down',
-    UNKNOWN: 'badge-unknown',
-    NOT_SERVER: 'badge-not_server',
-    MAYBE: 'badge-maybe',
-  };
-
-  // ---- State ----
-  let overview = null;
-  let prevStats = null;
-
-  // ---- Fetch helpers ----
-  async function fetchStats() {
-    try {
-      const r = await fetch('/dashboard/api/stats');
-      return await r.json();
-    } catch { return null; }
-  }
-
-  async function fetchOverview() {
-    try {
-      const r = await fetch('/dashboard/api/overview');
-      return await r.json();
-    } catch { return null; }
-  }
-
-  // ---- Render functions ----
-  function renderHeader(data) {
-    const s = data.server;
-    if (tsState && tsState.state === 'connected') {
-      $('#statusDot').className = 'status-dot';
-      $('#statusText').textContent = 'ONLINE';
-      $('#serverInfo').textContent = s.tailscale_ip + ' // ' + s.hostname;
-    } else if (tsState && tsState.state === 'not_connected') {
-      $('#statusDot').className = 'status-dot not-connected';
-      $('#statusText').textContent = 'NOT CONNECTED';
-      $('#serverInfo').textContent = 'Tailscale installed but not authenticated';
-    } else if (tsState && tsState.state === 'not_installed') {
-      $('#statusDot').className = 'status-dot not-installed';
-      $('#statusText').textContent = 'NO TAILSCALE';
-      $('#serverInfo').textContent = 'Tailscale not installed - local mode';
-    } else {
-      $('#statusDot').className = 'status-dot';
-      $('#statusText').textContent = 'ONLINE';
-      $('#serverInfo').textContent = s.tailscale_ip + ' // ' + s.hostname;
-    }
-    $('#uptime').textContent = formatUptime(s.uptime_seconds);
-  }
-
-  function renderStats(data) {
-    const prev = {
-      local: parseInt($('#localAgentCount').textContent) || 0,
-      remote: parseInt($('#remoteAgentCount').textContent) || 0,
-      peer: parseInt($('#peerCount').textContent) || 0,
-      party: parseInt($('#partyServerCount').textContent) || 0,
-    };
-    const vals = {
-      local: data.agents.local_count,
-      remote: data.agents.remote_count,
-      peer: data.peers.total,
-      party: data.peers.party_servers,
-    };
-    if (vals.local !== prev.local) { $('#localAgentCount').textContent = vals.local; flashEl($('#localAgentCount')); }
-    if (vals.remote !== prev.remote) { $('#remoteAgentCount').textContent = vals.remote; flashEl($('#remoteAgentCount')); }
-    if (vals.peer !== prev.peer) { $('#peerCount').textContent = vals.peer; flashEl($('#peerCount')); }
-    if (vals.party !== prev.party) { $('#partyServerCount').textContent = vals.party; flashEl($('#partyServerCount')); }
-  }
-
-  function renderTopology(data) {
-    const svg = $('#topologySvg');
-    const peers = data.peers.details || [];
-    const cx = 250, cy = 150, radius = 100;
-
-    let html = '';
-
-    // Center node
-    html += '<circle cx="' + cx + '" cy="' + cy + '" r="24" fill="rgba(0,255,240,0.15)" stroke="#00fff0" stroke-width="2">';
-    html += '<animate attributeName="r" values="24;26;24" dur="3s" repeatCount="indefinite"/>';
-    html += '</circle>';
-    html += '<text x="' + cx + '" y="' + cy + '" text-anchor="middle" dominant-baseline="central" fill="#00fff0" font-family="var(--font-mono)" font-size="10" font-weight="700">SELF</text>';
-    html += '<text x="' + cx + '" y="' + (cy + 38) + '" text-anchor="middle" class="topo-label">' + data.server.tailscale_ip + '</text>';
-
-    if (peers.length === 0) {
-      html += '<text x="' + cx + '" y="' + (cy + 60) + '" text-anchor="middle" fill="#6a6a8a" font-family="var(--font-mono)" font-size="11">No peers discovered</text>';
-    }
-
-    peers.forEach(function(p, i) {
-      const angle = (2 * Math.PI * i / Math.max(peers.length, 1)) - Math.PI / 2;
-      const px = cx + radius * Math.cos(angle);
-      const py = cy + radius * Math.sin(angle);
-      const color = statusColors[p.status] || '#6a6a8a';
-      const opacity = (p.status === 'PARTY_SERVER' || p.status === 'DEGRADED' || p.status === 'SUSPECT') ? 1 : 0.4;
-
-      // Connection line
-      html += '<line x1="' + cx + '" y1="' + cy + '" x2="' + px + '" y2="' + py + '" stroke="' + color + '" stroke-width="1" opacity="' + (opacity * 0.3) + '"/>';
-
-      // Peer node
-      html += '<g class="topo-node"><circle cx="' + px + '" cy="' + py + '" r="16" fill="rgba(255,255,255,0.03)" stroke="' + color + '" stroke-width="1.5" opacity="' + opacity + '"/>';
-      html += '<text x="' + px + '" y="' + py + '" text-anchor="middle" dominant-baseline="central" fill="' + color + '" font-family="var(--font-mono)" font-size="8" opacity="' + opacity + '">' + p.ip.split('.').slice(-1)[0] + '</text></g>';
-
-      // IP label
-      html += '<text x="' + px + '" y="' + (py + 26) + '" text-anchor="middle" class="topo-label">' + p.ip + '</text>';
-    });
-
-    svg.innerHTML = html;
-  }
-
-  function renderPeerTable(data) {
-    const tbody = $('#peerTableBody');
-    const peers = data.peers.details || [];
-
-    if (peers.length === 0) {
-      tbody.innerHTML = '<tr><td colspan="4" class="empty-state">No peers discovered</td></tr>';
-      return;
-    }
-
-    // Sort: PARTY_SERVER first, then by severity
-    const order = { PARTY_SERVER: 0, DEGRADED: 1, SUSPECT: 2, MAYBE: 3, UNKNOWN: 4, NOT_SERVER: 5, DOWN: 6 };
-    const sorted = [...peers].sort(function(a, b) { return (order[a.status] || 99) - (order[b.status] || 99); });
-
-    tbody.innerHTML = sorted.map(function(p) {
-      const badge = statusBadgeClass[p.status] || 'badge-unknown';
-      const label = p.status === 'PARTY_SERVER' ? 'SERVER' : p.status === 'NOT_SERVER' ? 'NOT_SVR' : p.status;
-      return '<tr>'
-        + '<td>' + p.ip + '</td>'
-        + '<td><span class="badge ' + badge + '">' + label + '</span></td>'
-        + '<td>' + p.consecutiveFailures + '</td>'
-        + '<td>' + timeAgo(p.lastProbeAt) + '</td>'
-        + '</tr>';
-    }).join('');
-  }
-
-  function renderAgents(data) {
-    const container = $('#agentList');
-    const local = data.agents.local_agents || [];
-    const remote = data.agents.remote_agents || [];
-    const all = [
-      ...local.map(function(a) { return { ...a, type: 'local' }; }),
-      ...remote.map(function(a) { return { ...a, type: 'remote' }; }),
-    ];
-
-    if (all.length === 0) {
-      container.innerHTML = '<div class="empty-state">No agents registered</div>';
-      return;
-    }
-
-    container.innerHTML = all.map(function(a) {
-      const initials = (a.display_name || a.agent_id).substring(0, 2).toUpperCase();
-      const tags = [];
-      if (a.type === 'remote') {
-        tags.push('<span class="agent-tag">' + a.source_peer_ip + '</span>');
-        if (!a.reachable) tags.push('<span class="agent-tag unreachable">offline</span>');
-      } else {
-        tags.push('<span class="agent-tag">local</span>');
-      }
-      return '<div class="agent-card ' + a.type + '">'
-        + '<div class="agent-icon">' + initials + '</div>'
-        + '<div class="agent-info">'
-        + '<div class="agent-name">' + (a.display_name || a.agent_id) + '</div>'
-        + '<div class="agent-id">' + a.agent_id + '</div>'
-        + '</div>'
-        + '<div class="agent-meta">' + tags.join('') + '</div>'
-        + '</div>';
-    }).join('');
-  }
-
-  // Build agent_id \u2192 display_name lookup from local + remote agents
-  function buildNameMap(data) {
-    const map = {};
-    const all = [...(data.agents.local_agents || []), ...(data.agents.remote_agents || [])];
-    for (const a of all) { map[a.agent_id] = a.display_name || a.agent_id; }
-    return map;
-  }
-
-  function resolveName(map, id) { return map[id] || id; }
-
-  function renderMessages(data) {
-    const container = $('#msgFeed');
-    const msgs = data.messages.recent || [];
-
-    if (msgs.length === 0) {
-      container.innerHTML = '<div class="empty-state">No recent messages</div>';
-      return;
-    }
-
-    const names = buildNameMap(data);
-
-    container.innerHTML = msgs.map(function(m) {
-      const dir = m.direction === 'received' ? 'received' : '';
-      const arrow = m.direction === 'received' ? '&#8592;' : '&#8594;';
-      const flow = m.direction === 'received'
-        ? resolveName(names, m.sender_id) + ' <span class="arrow">' + arrow + '</span> ' + resolveName(names, m.agent_id)
-        : resolveName(names, m.agent_id) + ' <span class="arrow">' + arrow + '</span> ' + resolveName(names, m.recipient_id) || 'broadcast';
-      return '<div class="msg-item ' + dir + '">'
-        + '<div class="msg-top">'
-        + '<div class="msg-flow">' + flow + '</div>'
-        + '<div class="msg-time">' + timeAgo(m.timestamp) + '</div>'
-        + '</div>'
-        + '<div class="msg-content">' + (m.summary || m.content) + '</div>'
-        + '</div>';
-    }).join('');
-  }
-
-  function renderAll(data) {
-    renderHeader(data);
-    renderStats(data);
-    renderTopology(data);
-    renderPeerTable(data);
-    renderAgents(data);
-    renderMessages(data);
-  }
-
-  // ---- Polling ----
-  let fullTimer = null;
-  let fastTimer = null;
-
-  async function fullRefresh() {
-    const data = await fetchOverview();
-    if (!data) {
-      $('#statusDot').className = 'status-dot offline';
-      $('#statusText').textContent = 'OFFLINE';
-      return;
-    }
-    overview = data;
-    renderAll(data);
-  }
-
-  async function fastRefresh() {
-    const stats = await fetchStats();
-    if (!stats) return;
-    const changed = JSON.stringify(stats) !== JSON.stringify(prevStats);
-    prevStats = stats;
-    if (changed) {
-      fullRefresh();
-    }
-  }
-
-  // ---- Init ----
-  fullRefresh();
-  fastTimer = setInterval(fastRefresh, 3000);
-  fullTimer = setInterval(fullRefresh, 5000);
-
-  // Clipboard click delegation for .cmd elements
-  document.addEventListener('click', function(e) {
-    var cmd = e.target.closest('.cmd');
-    if (!cmd) return;
-    var text = cmd.getAttribute('data-clipboard');
-    if (text) {
-      navigator.clipboard.writeText(text).then(function() {
-        var hint = cmd.querySelector('.copy-hint');
-        if (hint) hint.textContent = 'Copied!';
-      });
-    }
-  });
-
-  // Update uptime display every second
-  setInterval(function() {
-    if (overview && overview.server) {
-      overview.server.uptime_seconds++;
-      $('#uptime').textContent = formatUptime(overview.server.uptime_seconds);
-    }
-  }, 1000);
-
-  // ---- Join Modal Tabs ----
-  const joinTabs = $$('#joinTabs .tab');
-  joinTabs.forEach(function(tab) {
-    tab.addEventListener('click', function() {
-      joinTabs.forEach(function(t) { t.classList.remove('active'); });
-      tab.classList.add('active');
-      // Toggle tab contents
-      const target = tab.getAttribute('data-tab');
-      $$('.tab-content').forEach(function(tc) { tc.classList.remove('active'); });
-      if (target === 'interactive') {
-        $('#tabInteractive').classList.add('active');
-      } else {
-        $('#tabAuthkey').classList.add('active');
-      }
-    });
-  });
-
-  // ---- Join Network Modal (open/close) ----
-  const joinModal = $('#joinModal');
-  const btnJoin = $('#btnJoinNetwork');
-  const btnCancel = $('#btnCancelJoin');
-  const btnCancelAuthkey = $('#btnCancelAuthkey');
-  const btnSubmit = $('#btnSubmitJoin');
-  const authKeyInput = $('#authKeyInput');
-  const joinStatus = $('#joinStatus');
-
-  function openJoinModal() {
-    // Reset both tabs
-    joinStatus.className = 'modal-status';
-    joinStatus.textContent = '';
-    authKeyInput.value = '';
-    $('#interactiveStatus').className = 'modal-status';
-    $('#interactiveStatus').textContent = '';
-    // Default to Interactive tab
-    $$('#joinTabs .tab').forEach(function(t) { t.classList.remove('active'); });
-    $$('#joinTabs .tab')[0].classList.add('active');
-    $$('.tab-content').forEach(function(tc) { tc.classList.remove('active'); });
-    $('#tabInteractive').classList.add('active');
-    joinModal.classList.add('open');
-  }
-
-  function closeJoinModal() {
-    joinModal.classList.remove('open');
-  }
-
-  btnJoin.addEventListener('click', function() {
-    // Decide action based on Tailscale state
-    if (tsState && tsState.state === 'connected') {
-      openLogoutModal();
-    } else if (tsState && tsState.state === 'not_installed') {
-      doInstallTailscale();
-    } else {
-      openJoinModal();
-    }
-  });
-  btnCancel.addEventListener('click', closeJoinModal);
-  btnCancelAuthkey.addEventListener('click', closeJoinModal);
-  joinModal.addEventListener('click', function(e) {
-    if (e.target === joinModal) closeJoinModal();
-  });
-  authKeyInput.addEventListener('keydown', function(e) {
-    if (e.key === 'Enter') btnSubmit.click();
-    if (e.key === 'Escape') closeJoinModal();
-  });
-
-  // ---- Auth Key submit ----
-  btnSubmit.addEventListener('click', async function() {
-    const key = authKeyInput.value.trim();
-    if (!key) {
-      authKeyInput.focus();
-      return;
-    }
-    btnSubmit.disabled = true;
-    btnSubmit.innerHTML = '<span class="spinner"></span>Connecting...';
-    joinStatus.className = 'modal-status';
-    joinStatus.textContent = '';
-
-    try {
-      const r = await fetch('/dashboard/api/join-network', {
-        method: 'POST',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({ auth_key: key }),
-      });
-      const data = await r.json();
-      if (data.success) {
-        joinStatus.className = 'modal-status success';
-        joinStatus.textContent = 'Successfully joined network!';
-        btnJoin.textContent = 'Logout';
-        btnJoin.className = 'btn-join btn-logout';
-        setTimeout(function() { closeJoinModal(); checkTailscaleStatus(); fullRefresh(); }, 1500);
-      } else {
-        joinStatus.className = 'modal-status error';
-        joinStatus.textContent = data.output || 'Failed to join network';
-      }
-    } catch (e) {
-      joinStatus.className = 'modal-status error';
-      joinStatus.textContent = 'Network error: ' + (e.message || 'unknown');
-    }
-    btnSubmit.disabled = false;
-    btnSubmit.textContent = 'Connect';
-  });
-
-  // ---- Interactive Login ----
-  const btnInteractiveLogin = $('#btnInteractiveLogin');
-  btnInteractiveLogin.addEventListener('click', async function() {
-    const statusEl = $('#interactiveStatus');
-    statusEl.className = 'modal-status';
-    statusEl.textContent = '';
-    btnInteractiveLogin.disabled = true;
-    btnInteractiveLogin.innerHTML = '<span class="spinner"></span>Opening browser...';
-
-    try {
-      const r = await fetch('/dashboard/api/tailscale-login', { method: 'POST' });
-      const data = await r.json();
-
-      if (data.success && data.url) {
-        // Open the auth URL in a new tab
-        window.open(data.url, '_blank');
-        statusEl.className = 'modal-status success';
-        statusEl.textContent = 'Authentication page opened in your browser. Waiting for connection...';
-
-        // Poll for connection
-        var pollCount = 0;
-        var pollInterval = setInterval(async function() {
-          pollCount++;
-          if (pollCount > 40) { // 2 minutes timeout
-            clearInterval(pollInterval);
-            statusEl.className = 'modal-status error';
-            statusEl.textContent = 'Timed out waiting for authentication. Please try again.';
-            btnInteractiveLogin.disabled = false;
-            btnInteractiveLogin.textContent = 'Open Browser Login';
-            return;
-          }
-          try {
-            var sr = await fetch('/dashboard/api/tailscale-status');
-            var sd = await sr.json();
-            if (sd.state === 'connected') {
-              clearInterval(pollInterval);
-              btnJoin.textContent = 'Logout';
-              btnJoin.className = 'btn-join btn-logout';
-              closeJoinModal();
-              checkTailscaleStatus();
-              fullRefresh();
-              return;
-            }
-          } catch { /* poll error, continue */ }
-        }, 3000);
-      } else {
-        statusEl.className = 'modal-status error';
-        statusEl.textContent = data.output || 'Failed to start interactive login';
-        btnInteractiveLogin.disabled = false;
-        btnInteractiveLogin.textContent = 'Open Browser Login';
-      }
-    } catch (e) {
-      statusEl.className = 'modal-status error';
-      statusEl.textContent = 'Network error: ' + (e.message || 'unknown');
-      btnInteractiveLogin.disabled = false;
-      btnInteractiveLogin.textContent = 'Open Browser Login';
-    }
-  });
-
-  // ---- Logout Modal ----
-  const logoutModal = $('#logoutModal');
-  const btnConfirmLogout = $('#btnConfirmLogout');
-  const btnCancelLogout = $('#btnCancelLogout');
-  const logoutStatus = $('#logoutStatus');
-
-  function openLogoutModal() {
-    logoutStatus.className = 'modal-status';
-    logoutStatus.textContent = '';
-    logoutModal.classList.add('open');
-  }
-
-  btnCancelLogout.addEventListener('click', function() { logoutModal.classList.remove('open'); });
-  logoutModal.addEventListener('click', function(e) { if (e.target === logoutModal) logoutModal.classList.remove('open'); });
-
-  btnConfirmLogout.addEventListener('click', async function() {
-    btnConfirmLogout.disabled = true;
-    btnConfirmLogout.innerHTML = '<span class="spinner"></span>Logging out...';
-    logoutStatus.className = 'modal-status';
-    logoutStatus.textContent = '';
-
-    try {
-      const r = await fetch('/dashboard/api/logout', { method: 'POST' });
-      const data = await r.json();
-      logoutModal.classList.remove('open');
-      if (data.success) {
-        checkTailscaleStatus();
-        fullRefresh();
-      } else {
-        alert('Logout failed: ' + (data.output || 'unknown error'));
-      }
-    } catch (e) {
-      logoutModal.classList.remove('open');
-      alert('Network error: ' + (e.message || 'unknown'));
-    }
-    btnConfirmLogout.disabled = false;
-    btnConfirmLogout.textContent = 'Log Out';
-  });
-
-  // ---- Install Tailscale ----
-  async function doInstallTailscale() {
-    if (!confirm('Install Tailscale on this machine?')) return;
-
-    btnJoin.disabled = true;
-    btnJoin.innerHTML = '<span class="spinner"></span>Installing...';
-
-    try {
-      const r = await fetch('/dashboard/api/install-tailscale', { method: 'POST' });
-      const data = await r.json();
-      if (data.success) {
-        btnJoin.textContent = 'Installed';
-        btnJoin.disabled = false;
-        checkTailscaleStatus();
-        fullRefresh();
-      } else {
-        alert('Installation failed: ' + (data.output || 'unknown error'));
-        btnJoin.textContent = 'Install Tailscale';
-        btnJoin.className = 'btn-join btn-install';
-        btnJoin.disabled = false;
-      }
-    } catch (e) {
-      alert('Network error: ' + (e.message || 'unknown'));
-      btnJoin.textContent = 'Install Tailscale';
-      btnJoin.className = 'btn-join btn-install';
-      btnJoin.disabled = false;
-    }
-  }
-
-  // Check initial Tailscale status (tri-state)
-  let tsState = null;
-  let tsInstallInfo = null;
-
-  async function checkTailscaleStatus() {
-    try {
-      const r = await fetch('/dashboard/api/tailscale-status');
-      tsState = await r.json();
-    } catch { tsState = { state: 'not_installed', platform: 'unknown' }; }
-
-    const dot = $('#statusDot');
-    const text = $('#statusText');
-    const btnJoin = $('#btnJoinNetwork');
-    const panel = $('#tsPanel');
-
-    if (tsState.state === 'connected') {
-      dot.className = 'status-dot';
-      text.textContent = 'ONLINE';
-      btnJoin.textContent = 'Logout';
-      btnJoin.className = 'btn-join btn-logout';
-      btnJoin.style.display = '';
-      panel.style.display = 'none';
-    } else if (tsState.state === 'not_installed') {
-      dot.className = 'status-dot not-installed';
-      text.textContent = 'NOT INSTALLED';
-      btnJoin.textContent = 'Install Tailscale';
-      btnJoin.className = 'btn-join btn-install';
-      btnJoin.style.display = '';
-      await renderNotInstalledPanel();
-    } else {
-      dot.className = 'status-dot not-connected';
-      text.textContent = 'NOT CONNECTED';
-      btnJoin.textContent = 'Join Network';
-      btnJoin.className = 'btn-join';
-      btnJoin.style.display = '';
-      await renderNotConnectedPanel();
-    }
-  }
-
-  async function fetchInstallInfo() {
-    if (tsInstallInfo) return tsInstallInfo;
-    try {
-      const r = await fetch('/dashboard/api/tailscale-install-info');
-      tsInstallInfo = await r.json();
-    } catch { tsInstallInfo = null; }
-    return tsInstallInfo;
-  }
-
-  async function renderNotInstalledPanel() {
-    const info = await fetchInstallInfo();
-    const panel = $('#tsPanel');
-    let html = '<div class="ts-panel-title not-installed">Tailscale Not Installed</div>';
-    html += '<div class="ts-info-row"><span class="label">Status:</span><span class="value" style="color:var(--red)">Tailscale is not detected on this system</span></div>';
-
-    if (info && info.commands && info.commands.length > 0) {
-      html += '<div class="ts-install-guide">';
-      html += '<div style="color:var(--muted);margin-bottom:6px">Install for ' + info.os + ':</div>';
-      info.commands.forEach(function(cmd) {
-        const display = info.needs_sudo ? 'sudo ' + cmd : cmd;
-        html += '<div class="cmd" data-clipboard="' + display.replace(/"/g, '&quot;') + '">';
-        html += '<code>' + display + '</code><span class="copy-hint">Click to copy</span></div>';
-      });
-      if (info.download_url) {
-        html += '<div style="margin-top:8px">Download: <a href="' + info.download_url + '" target="_blank">' + info.download_url + '</a></div>';
-      }
-      html += '</div>';
-    }
-
-    html += '<div class="ts-setup-hint">Or click the <strong>Install Tailscale</strong> button above, or run <code style="color:var(--cyan)">npx open-party setup</code></div>';
-    html += '<button class="btn-redetect" onclick="window.__redetectTailscale()">Re-detect</button>';
-    panel.innerHTML = html;
-    panel.style.display = 'block';
-  }
-
-  async function renderNotConnectedPanel() {
-    const panel = $('#tsPanel');
-
-    let html = '<div class="ts-panel-title not-connected">Tailscale Not Connected</div>';
-    html += '<div class="ts-info-row"><span class="label">Status:</span><span class="value" style="color:var(--yellow)">Installed but not authenticated</span></div>';
-    html += '<div class="ts-setup-hint">Use the <strong>Join Network</strong> button above to log in</div>';
-    html += '<button class="btn-redetect" onclick="window.__redetectTailscale()">Re-detect</button>';
-    panel.innerHTML = html;
-    panel.style.display = 'block';
-  }
-
-  window.__redetectTailscale = async function() {
-    const panel = $('#tsPanel');
-    panel.innerHTML = '<div style="color:var(--muted);padding:12px"><span class="spinner"></span> Re-detecting Tailscale...</div>';
-    try {
-      await fetch('/dashboard/api/tailscale-detect', { method: 'POST' });
-    } catch { /* ignore */ }
-    await checkTailscaleStatus();
-    fullRefresh();
-  };
-
-  checkTailscaleStatus();
-
-})();
-</script>
-</body>
-</html>`;
-  }
-});
-
-// src/server/routes/dashboard.ts
-var dashboardRoutes, activeLogin;
-var init_dashboard = __esm({
-  "src/server/routes/dashboard.ts"() {
-    "use strict";
-    init_dist();
-    init_models();
-    init_dashboard_html();
-    init_tailscale();
-    init_state();
-    init_logger();
-    dashboardRoutes = new Hono2();
-    dashboardRoutes.get("/", (c) => {
-      return c.html(DASHBOARD_HTML);
-    });
-    dashboardRoutes.get("/api/stats", async (c) => {
-      const localAgents = registry.listAll();
-      const remoteAgents = discovery.getReachableRemoteAgents();
-      const peerStates = discovery.getPeerStates();
-      const partyServers = peerStates.filter((p) => p.status === "PARTY_SERVER" || p.status === "DEGRADED" || p.status === "SUSPECT");
-      return c.json({
-        local_agent_count: localAgents.length,
-        remote_agent_count: remoteAgents.length,
-        peer_count: peerStates.length,
-        party_server_count: partyServers.length
-      });
-    });
-    dashboardRoutes.get("/api/overview", async (c) => {
-      let hostname = "127.0.0.1";
-      try {
-        hostname = getTailnetHostname();
-      } catch {
-      }
-      const localAgents = sanitizeAgentList(registry.listAll());
-      const remoteEntries = discovery.getRemoteAgentEntries();
-      const peerStates = discovery.getPeerStates();
-      const seen = /* @__PURE__ */ new Set();
-      const recentMessages = [];
-      for (const agent of localAgents) {
-        const history = messageQueue.getHistory(agent.agent_id, 5);
-        for (const entry of history) {
-          const key = `${entry.sender_id}:${entry.recipient_id ?? ""}:${Math.floor(entry.timestamp)}`;
-          if (seen.has(key)) continue;
-          seen.add(key);
-          recentMessages.push({ agent_id: agent.agent_id, ...entry });
-        }
-      }
-      recentMessages.sort((a, b) => b.timestamp - a.timestamp);
-      if (recentMessages.length > 20) recentMessages.length = 20;
-      const partyServers = peerStates.filter(
-        (p) => p.status === "PARTY_SERVER" || p.status === "DEGRADED" || p.status === "SUSPECT"
-      );
-      return c.json({
-        server: {
-          status: "ok",
-          tailscale_ip: getSelfIp(),
-          hostname,
-          uptime_seconds: Math.floor((Date.now() - STARTED_AT) / 1e3)
-        },
-        agents: {
-          local_count: localAgents.length,
-          remote_count: remoteEntries.length,
-          local_agents: localAgents,
-          remote_agents: remoteEntries.map((e) => ({
-            ...sanitizeAgentList([e.agentInfo])[0],
-            source_peer_ip: e.sourcePeerIp,
-            reachable: e.reachable
-          }))
-        },
-        peers: {
-          total: peerStates.length,
-          party_servers: partyServers.length,
-          down: peerStates.filter((p) => p.status === "DOWN").length,
-          unknown: peerStates.filter((p) => p.status === "UNKNOWN" || p.status === "MAYBE").length,
-          details: peerStates
-        },
-        messages: {
-          recent: recentMessages
-        }
-      });
-    });
-    dashboardRoutes.get("/api/tailscale-status", async (c) => {
-      try {
-        return c.json(getTailscaleInstallationStatus());
-      } catch (e) {
-        return c.json({ state: "not_installed", platform: process.platform, error: e.message });
-      }
-    });
-    dashboardRoutes.post("/api/tailscale-detect", async (c) => {
-      resetTailscaleBinaryCache();
-      const state = getTailscaleInstallationStatus();
-      if (state.state === "connected") {
-        refreshSelfIp();
-      }
-      return c.json(state);
-    });
-    dashboardRoutes.get("/api/tailscale-install-info", async (c) => {
-      return c.json(getInstallInstructions(process.platform));
-    });
-    dashboardRoutes.post("/api/join-network", async (c) => {
-      try {
-        const body = await c.req.json();
-        const authKey = (body.auth_key ?? "").trim();
-        if (!authKey) {
-          return c.json({ success: false, output: "auth_key is required" }, 400);
-        }
-        const result = joinTailnet(authKey);
-        logger.info("Dashboard", `Join network: ${result.success ? "success" : "failed"}`);
-        return c.json(result, result.success ? 200 : 500);
-      } catch (e) {
-        return c.json({ success: false, output: e.message }, 500);
-      }
-    });
-    activeLogin = null;
-    dashboardRoutes.post("/api/logout", async (c) => {
-      const result = logoutTailscale();
-      logger.info("Dashboard", `Logout: ${result.success ? "success" : "failed"}`);
-      if (result.success) {
-        resetTailscaleBinaryCache();
-        refreshSelfIp();
-      }
-      return c.json(result, result.success ? 200 : 500);
-    });
-    dashboardRoutes.post("/api/tailscale-login", async (c) => {
-      if (activeLogin?.url) {
-        return c.json({ success: true, url: activeLogin.url });
-      }
-      const { promise, process: process2 } = startInteractiveLogin();
-      activeLogin = { process: process2 };
-      logger.info("Dashboard", "Tailscale login initiated");
-      const result = await promise;
-      if (result.success && result.url) {
-        activeLogin.url = result.url;
-        return c.json({ success: true, url: result.url });
-      }
-      activeLogin = null;
-      return c.json({ success: false, output: result.output }, 500);
-    });
-    dashboardRoutes.post("/api/install-tailscale", async (c) => {
-      const { installTailscale: installTailscale2 } = await Promise.resolve().then(() => (init_tailscale_installer(), tailscale_installer_exports));
-      const result = await installTailscale2(process.platform);
-      logger.info("Dashboard", `Install Tailscale: ${result.success ? "success" : "failed"}`);
-      if (result.success) {
-        resetTailscaleBinaryCache();
-      }
-      return c.json(result, result.success ? 200 : 500);
-    });
-  }
-});
-
-// src/server/index.ts
-var server_exports = {};
-import { mkdirSync as mkdirSync5, writeFileSync as writeFileSync4, unlinkSync as unlinkSync4 } from "fs";
-import { join as join7, dirname as dirname4 } from "path";
-import { homedir as homedir6 } from "os";
-async function periodicCleanup() {
-  while (!lifecycleController.signal.aborted) {
-    try {
-      const removed = registry.cleanupStale(HEARTBEAT_TIMEOUT);
-      if (removed.length > 0) {
-        logger.info("Cleanup", `Removed ${removed.length} stale agent(s): ${removed.join(", ")}`);
-      }
-    } catch (e) {
-      logger.error("Cleanup", "Error during cleanup", e);
-    }
-    await abortableSleep(CLEANUP_INTERVAL * 1e3, lifecycleController.signal);
-  }
-}
-function pidFilePath2() {
-  const pluginData = process.env.CLAUDE_PLUGIN_DATA || "";
-  if (pluginData) return join7(pluginData, "server.pid");
-  return join7(homedir6(), ".open-party", "server.pid");
-}
-async function performShutdown(server, pidPath) {
-  if (shutdownInitiated) return;
-  shutdownInitiated = true;
-  logger.info("Shutdown", "Shutting down Party Server...");
-  try {
-    lifecycleController.abort();
-    getSnapshotManager()?.cancelDebounce();
-    try {
-      getSnapshotManager()?.writeSnapshot(registry.listAll(), messageQueue.getHistorySnapshot());
-      logger.info("Shutdown", "Final snapshot written.");
-    } catch (error) {
-      logger.error("Shutdown", "Failed to write final snapshot", error);
-    }
-    if (server.closeAllConnections) {
-      server.closeAllConnections();
-    }
-    if (process.platform === "win32") {
-      await new Promise((r) => setTimeout(r, 500));
-    }
-    await new Promise((resolve4, reject) => {
-      server.close((err) => err ? reject(err) : resolve4());
-    });
-    if (process.platform === "win32") {
-      await new Promise((r) => setTimeout(r, 500));
-    }
-    getSnapshotManager()?.removeShutdownMarker();
-    try {
-      unlinkSync4(pidPath);
-    } catch {
-    }
-    logger.info("Shutdown", "Party Server shut down cleanly.");
-  } catch (error) {
-    logger.error("Shutdown", "Error during shutdown sequence", error);
-  } finally {
-    process.exit(0);
-  }
+async function performShutdown(server, pidPath) {
+  if (shutdownInitiated) return;
+  shutdownInitiated = true;
+  logger.info("Shutdown", "Shutting down Party Server...");
+  try {
+    lifecycleController.abort();
+    try {
+      getSnapshotManager()?.writeSnapshot(registry.listAll(), messageQueue.getHistorySnapshot());
+      logger.info("Shutdown", "Final snapshot written.");
+    } catch (error) {
+      logger.error("Shutdown", "Failed to write final snapshot", error);
+    }
+    if (server.closeAllConnections) {
+      server.closeAllConnections();
+    }
+    if (process.platform === "win32") {
+      await new Promise((r) => setTimeout(r, 500));
+    }
+    await new Promise((resolve4, reject) => {
+      server.close((err) => err ? reject(err) : resolve4());
+    });
+    if (process.platform === "win32") {
+      await new Promise((r) => setTimeout(r, 500));
+    }
+    getSnapshotManager()?.removeShutdownMarker();
+    try {
+      unlinkSync4(pidPath);
+    } catch {
+    }
+    logger.info("Shutdown", "Party Server shut down cleanly.");
+  } catch (error) {
+    logger.error("Shutdown", "Error during shutdown sequence", error);
+  } finally {
+    process.exit(0);
+  }
 }
 async function main() {
   const pidPath = pidFilePath2();
@@ -5665,7 +4508,7 @@ async function main() {
   const savedSnapshot = sm.loadSnapshot();
   if (savedSnapshot) {
     recoveredAgents = sm.hydrateAgents(registry, getSelfIp());
-    recoveredHistoryEntries = sm.hydrateHistory(messageQueue);
+    recoveredHistoryEntries = sm.hydrateBuffers(messageQueue);
     if (recoveredAgents > 0 || recoveredHistoryEntries > 0) {
       logger.info(
         "Recovery",
@@ -5682,7 +4525,7 @@ async function main() {
   const snapshotLoopPromise = sm.startSnapshotLoop(
     lifecycleController.signal,
     () => registry.listAll(),
-    () => messageQueue.getHistorySnapshot()
+    () => messageQueue.getBufferSnapshots()
   );
   const shutdownHandler = () => void performShutdown(server, pidPath);
   process.on("SIGINT", shutdownHandler);
@@ -5706,7 +4549,6 @@ var init_server = __esm({
     init_state();
     init_agent();
     init_proxy();
-    init_dashboard();
     app = new Hono2();
     app.use("*", cors());
     app.use("*", async (c, next) => {
@@ -5730,7 +4572,6 @@ var init_server = __esm({
     });
     app.route("/agent", agentRoutes);
     app.route("/proxy", proxyRoutes);
-    app.route("/dashboard", dashboardRoutes);
     shutdownInitiated = false;
     main().catch((e) => {
       logger.error("Server", "Fatal error", e);
@@ -5746,849 +4587,138 @@ var init_server = __esm({
 });
 
 // src/cli/setup.ts
-init_tailscale();
-init_tailscale_installer();
-
-// src/cli/agent-detector.ts
-import { existsSync as existsSync2 } from "fs";
-import { join as join2 } from "path";
-import { homedir } from "os";
+import { existsSync as existsSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2, mkdirSync as mkdirSync2, readdirSync, statSync } from "fs";
+import { join as join2, dirname as dirname2, resolve as resolve2 } from "path";
+import { homedir as homedir2, platform } from "os";
 import { execSync as execSync2 } from "child_process";
-function isExecutableInPath(name) {
-  try {
-    const which = process.platform === "win32" ? "where" : "which";
-    execSync2(`${which} ${name}`, { timeout: 3e3, stdio: "pipe", windowsHide: true });
-    return true;
-  } catch {
-    return false;
-  }
-}
-function detectClaudeCode() {
-  const configDir = join2(homedir(), ".claude");
-  const settingsPath = join2(configDir, "settings.json");
-  return {
-    type: "claude-code",
-    name: "Claude Code",
-    detected: existsSync2(settingsPath) || isExecutableInPath("claude"),
-    configPath: settingsPath
-  };
-}
-function detectOpenClaw() {
-  const configPath = join2(homedir(), ".openclaw", "openclaw.json");
-  if (isExecutableInPath("openclaw") || isExecutableInPath("openclaw.mjs")) {
-    return { type: "openclaw", name: "OpenClaw", detected: true, configPath };
-  }
-  const candidatePaths = [
-    join2(homedir(), ".openclaw", "openclaw.mjs"),
-    join2(homedir(), ".openclaw", "openclaw")
-  ];
-  for (const p of candidatePaths) {
-    if (existsSync2(p)) {
-      return { type: "openclaw", name: "OpenClaw", detected: true, configPath };
-    }
-  }
-  return { type: "openclaw", name: "OpenClaw", detected: false, configPath };
-}
-function detectAgents() {
-  return [detectClaudeCode(), detectOpenClaw()];
-}
-
-// src/cli/agent-installer.ts
-import { existsSync as existsSync3, readFileSync, writeFileSync, mkdirSync, cpSync, rmSync, readdirSync, statSync } from "fs";
-import { createHash } from "crypto";
-import { join as join3, dirname, resolve } from "path";
-import { homedir as homedir2 } from "os";
-function ensureDir(filePath) {
-  const dir = dirname(filePath);
-  if (!existsSync3(dir)) {
-    mkdirSync(dir, { recursive: true });
-  }
-}
-function readJsonFile(filePath, fallback) {
-  if (!existsSync3(filePath)) return fallback;
-  try {
-    return JSON.parse(readFileSync(filePath, "utf-8"));
-  } catch {
-    return fallback;
-  }
-}
-function writeJsonFile(filePath, data) {
-  ensureDir(filePath);
-  writeFileSync(filePath, JSON.stringify(data, null, 2) + "\n");
-}
-function findPluginDistDir() {
-  const distDir = resolve(import.meta.dirname ?? ".", "..", "claude-code");
-  if (!existsSync3(distDir)) return null;
-  try {
-    const entries = readdirSync(distDir);
-    const dirs = entries.filter((e) => e.startsWith("open-party-"));
-    if (dirs.length === 0) return null;
-    const pluginDir = join3(distDir, dirs[dirs.length - 1]);
-    if (existsSync3(join3(pluginDir, ".claude-plugin", "plugin.json"))) {
-      return pluginDir;
-    }
-  } catch (error) {
-    console.error("[Agent Installer] Failed to list plugin dist directory:", error instanceof Error ? error.message : String(error));
-  }
-  return null;
-}
-function findDistJsDir() {
-  const possiblePaths = [
-    // When installed globally via npm: <pkg-root>/dist/cli/index.js → <pkg-root>/dist/
-    resolve(import.meta.dirname ?? ".", "..")
-  ];
-  for (const p of possiblePaths) {
-    if (existsSync3(join3(p, "mcp-server.js")) && existsSync3(join3(p, "hook-handler.js"))) {
-      return p;
-    }
-  }
-  return null;
-}
-function getPluginVersion() {
-  const pluginDir = findPluginDistDir();
-  if (pluginDir) {
-    const manifest = readJsonFile(
-      join3(pluginDir, ".claude-plugin", "plugin.json"),
-      {}
-    );
-    if (manifest.version) return manifest.version;
-  }
-  const distJsDir = findDistJsDir();
-  if (distJsDir) {
-    const buildInfo = readJsonFile(
-      join3(distJsDir, "..", "BUILD_INFO.json"),
-      {}
-    );
-    if (buildInfo.version) return buildInfo.version;
-  }
-  try {
-    const pkg = JSON.parse(readFileSync(join3(import.meta.dirname ?? ".", "..", "..", "package.json"), "utf-8"));
-    if (pkg.version) return pkg.version;
-  } catch {
-  }
-  return "0.0.0";
-}
-function getMarketplaceDir() {
-  return join3(homedir2(), ".claude", "plugins", "marketplaces", "open-party");
-}
-function registerMarketplace(version, pluginDir) {
-  const marketplaceDir = getMarketplaceDir();
-  const pluginSourceDir = join3(marketplaceDir, "plugin");
-  const marketplacePluginDir = join3(marketplaceDir, ".claude-plugin");
-  if (!existsSync3(marketplacePluginDir)) {
-    mkdirSync(marketplacePluginDir, { recursive: true });
-  }
-  const marketplaceManifest = {
-    name: "open-party",
-    owner: { name: "Feynman Zhang" },
-    metadata: {
-      description: "Decentralized Agent communication network for Claude Code",
-      homepage: "https://github.com/FeynmanZhang/open-party"
-    },
-    plugins: [
-      {
-        name: "open-party",
-        version,
-        source: "./plugin",
-        description: "Decentralized Agent communication network for Claude Code"
-      }
-    ]
-  };
-  writeJsonFile(join3(marketplacePluginDir, "marketplace.json"), marketplaceManifest);
-  if (existsSync3(pluginSourceDir)) {
-    rmSync(pluginSourceDir, { recursive: true });
-  }
-  mkdirSync(pluginSourceDir, { recursive: true });
-  cpSync(pluginDir, pluginSourceDir, { recursive: true });
-  const knownMarketplacesPath = join3(homedir2(), ".claude", "plugins", "known_marketplaces.json");
-  const knownMarketplaces = readJsonFile(knownMarketplacesPath, {});
-  knownMarketplaces["open-party"] = {
-    source: {
-      source: "github",
-      repo: "FeynmanZhang/open-party"
-    },
-    installLocation: marketplaceDir,
-    lastUpdated: (/* @__PURE__ */ new Date()).toISOString()
-  };
-  writeJsonFile(knownMarketplacesPath, knownMarketplaces);
-}
-function installClaudeCode() {
-  const pluginDir = findPluginDistDir();
-  if (!pluginDir) {
-    return {
-      success: false,
-      error: 'Plugin package not found. Run "npm run build:plugin" first, or use "claude --plugin-dir" to install manually.'
-    };
-  }
-  const version = getPluginVersion();
-  const installDir = join3(homedir2(), ".claude", "plugins", "cache", "open-party", "open-party", version);
-  if (existsSync3(installDir)) {
-    rmSync(installDir, { recursive: true });
-  }
-  mkdirSync(installDir, { recursive: true });
-  cpSync(pluginDir, installDir, { recursive: true });
-  const mcpServerPath = join3(installDir, "dist", "mcp-server.js");
-  if (!existsSync3(mcpServerPath)) {
-    const distJsDir = findDistJsDir();
-    if (distJsDir) {
-      const targetDist = join3(installDir, "dist");
-      if (!existsSync3(targetDist)) mkdirSync(targetDist, { recursive: true });
-      for (const file of ["mcp-server.js", "hook-handler.js", "party-server.js"]) {
-        const src = join3(distJsDir, file);
-        if (existsSync3(src)) {
-          cpSync(src, join3(targetDist, file));
-        }
-      }
-      for (const file of ["mcp-server.js.map", "hook-handler.js.map", "party-server.js.map"]) {
-        const src = join3(distJsDir, file);
-        if (existsSync3(src)) {
-          cpSync(src, join3(targetDist, file));
-        }
-      }
-    }
-  }
-  const orphanedPath = join3(installDir, "dist", ".orphaned_at");
-  if (existsSync3(orphanedPath)) {
-    rmSync(orphanedPath);
-  }
-  registerMarketplace(version, pluginDir);
-  const pluginsJsonPath = join3(homedir2(), ".claude", "plugins", "installed_plugins.json");
-  const pluginsData = readJsonFile(
-    pluginsJsonPath,
-    { version: 2, plugins: {} }
-  );
-  if (!pluginsData.plugins) pluginsData.plugins = {};
-  if (pluginsData.plugins["open-party@local"]) {
-    delete pluginsData.plugins["open-party@local"];
-  }
-  pluginsData.plugins["open-party@open-party"] = [
-    {
-      scope: "user",
-      installPath: installDir,
-      version,
-      installedAt: (/* @__PURE__ */ new Date()).toISOString(),
-      lastUpdated: (/* @__PURE__ */ new Date()).toISOString()
-    }
-  ];
-  writeJsonFile(pluginsJsonPath, pluginsData);
-  const settingsPath = join3(homedir2(), ".claude", "settings.json");
-  const settings = readJsonFile(settingsPath, {});
-  if (settings.mcpServers?.["open-party"]) {
-    delete settings.mcpServers["open-party"];
-    if (Object.keys(settings.mcpServers).length === 0) {
-      delete settings.mcpServers;
-    }
-  }
-  if (!settings.enabledPlugins) {
-    settings.enabledPlugins = {};
-  }
-  if (settings.enabledPlugins["open-party@local"] !== void 0) {
-    delete settings.enabledPlugins["open-party@local"];
-  }
-  settings.enabledPlugins["open-party@open-party"] = true;
-  writeJsonFile(settingsPath, settings);
-  return {
-    success: true,
-    configPath: settingsPath
-  };
-}
-function findOpenclawDistDir() {
-  const distDir = resolve(import.meta.dirname ?? ".", "..", "openclaw");
-  if (!existsSync3(distDir)) return null;
-  try {
-    const entries = readdirSync(distDir);
-    const dirs = entries.filter((e) => e.startsWith("open-party-"));
-    if (dirs.length === 0) return null;
-    return join3(distDir, dirs[dirs.length - 1]);
-  } catch (error) {
-    console.error("[Agent Installer] Failed to list openclaw dist directory:", error instanceof Error ? error.message : String(error));
-  }
-  return null;
-}
-function installOpenClaw() {
-  const pluginDir = findOpenclawDistDir();
-  if (!pluginDir) {
-    return {
-      success: false,
-      error: 'OpenClaw plugin package not found. Run "npm run build:openclaw" first.'
-    };
-  }
-  const configPath = join3(homedir2(), ".openclaw", "openclaw.json");
-  const extensionDir = join3(homedir2(), ".openclaw", "extensions", "open-party");
-  if (existsSync3(extensionDir)) {
-    rmSync(extensionDir, { recursive: true });
-  }
-  mkdirSync(extensionDir, { recursive: true });
-  cpSync(pluginDir, extensionDir, { recursive: true });
-  const config = readJsonFile(configPath, {});
-  if (!config.plugins) config.plugins = {};
-  if (!config.plugins.entries) {
-    config.plugins.entries = {};
-  }
-  const entries = config.plugins.entries;
-  entries["open-party"] = {
-    enabled: true,
-    config: {
-      partyServerUrl: "http://127.0.0.1:8000",
-      heartbeatInterval: 3e4
-    }
-  };
-  const pluginsConfig = config.plugins;
-  if (!Array.isArray(pluginsConfig.allow)) {
-    pluginsConfig.allow = [];
-  }
-  const allowList = pluginsConfig.allow;
-  if (!allowList.includes("open-party")) {
-    allowList.push("open-party");
-  }
-  writeJsonFile(configPath, config);
-  const installsPath = join3(homedir2(), ".openclaw", "plugins", "installs.json");
-  const manifestPath = join3(extensionDir, "openclaw.plugin.json");
-  const entrySource = join3(extensionDir, "dist", "index.js");
-  let manifestHash = "";
-  try {
-    const manifestContent = readFileSync(manifestPath, "utf-8");
-    manifestHash = createHash("sha256").update(manifestContent).digest("hex");
-  } catch {
-  }
-  const stat = (filePath) => {
-    try {
-      return statSync(filePath);
-    } catch {
-      return void 0;
-    }
-  };
-  const mStat = stat(manifestPath);
-  const installs = readJsonFile(installsPath, { plugins: {} });
-  if (!installs.plugins) installs.plugins = {};
-  installs.plugins["open-party"] = [{
-    pluginId: "open-party",
-    manifestPath,
-    manifestHash,
-    manifestFile: mStat ? { size: mStat.size, mtimeMs: mStat.mtimeMs, ctimeMs: mStat.ctimeMs } : void 0,
-    source: entrySource,
-    rootDir: extensionDir,
-    origin: "local",
-    enabled: true,
-    startup: {
-      sidecar: false,
-      memory: false,
-      deferConfiguredChannelFullLoadUntilAfterListen: false,
-      agentHarnesses: []
-    },
-    compat: [],
-    enabledByDefault: true,
-    packageName: "@feynmanzhang/open-party-openclaw",
-    packageVersion: getPluginVersion()
-  }];
-  writeJsonFile(installsPath, installs);
-  return { success: true, configPath };
-}
-async function installPluginToAgent(agentType) {
-  switch (agentType) {
-    case "claude-code":
-      return installClaudeCode();
-    case "openclaw":
-      return installOpenClaw();
-    default:
-      return { success: false, error: `Unknown agent type: ${agentType}` };
-  }
-}
-
-// src/cli/tailscale-login.ts
-init_tailscale();
-import { spawn as spawn2 } from "child_process";
 
 // src/cli/tty-utils.ts
 import { createInterface } from "readline";
 function cyan(text) {
   return `\x1B[36m${text}\x1B[0m`;
-}
-function green(text) {
-  return `\x1B[32m${text}\x1B[0m`;
-}
-function yellow(text) {
-  return `\x1B[33m${text}\x1B[0m`;
-}
-function red(text) {
-  return `\x1B[31m${text}\x1B[0m`;
-}
-function bold(text) {
-  return `\x1B[1m${text}\x1B[0m`;
-}
-function dim(text) {
-  return `\x1B[2m${text}\x1B[0m`;
-}
-function createRl() {
-  return createInterface({ input: process.stdin, output: process.stdout });
-}
-function closeRl(rl) {
-  rl.close();
-}
-async function prompt(question) {
-  const rl = createInterface({ input: process.stdin, output: process.stdout });
-  return new Promise((resolve4) => {
-    rl.question(question, (answer) => {
-      rl.close();
-      resolve4(answer.trim());
-    });
-  });
-}
-async function select(options, opts) {
-  if (options.length === 0) throw new Error("select() requires at least one option");
-  if (options.length === 1) return options[0].value;
-  const message = opts?.message ?? "";
-  const wasRaw = process.stdin.isRaw;
-  if (process.stdin.isTTY) process.stdin.setRawMode(true);
-  try {
-    let cursor = 0;
-    const render = () => {
-      const lines = options.length + (message ? 1 : 0);
-      process.stdout.write(`\x1B[${lines}A\x1B[0J`);
-      if (message) {
-        process.stdout.write(`${message}
-`);
-      }
-      for (let i = 0; i < options.length; i++) {
-        const opt = options[i];
-        const prefix = i === cursor ? `${cyan("\u276F")} ` : "  ";
-        const label = i === cursor ? bold(opt.label) : opt.label;
-        const hintStr = opt.hint ? ` ${dim(opt.hint)}` : "";
-        process.stdout.write(`${prefix}${label}${hintStr}
-`);
-      }
-    };
-    if (message) {
-      process.stdout.write(`${message}
-`);
-    }
-    for (let i = 0; i < options.length; i++) {
-      const opt = options[i];
-      const prefix = i === cursor ? `${cyan("\u276F")} ` : "  ";
-      const label = i === cursor ? bold(opt.label) : opt.label;
-      const hintStr = opt.hint ? ` ${dim(opt.hint)}` : "";
-      process.stdout.write(`${prefix}${label}${hintStr}
-`);
-    }
-    return new Promise((resolve4) => {
-      const onKey = (ch, key) => {
-        if (key.name === "up" || key.sequence === "\x1B[A") {
-          cursor = (cursor - 1 + options.length) % options.length;
-          render();
-        } else if (key.name === "down" || key.sequence === "\x1B[B") {
-          cursor = (cursor + 1) % options.length;
-          render();
-        } else if (key.name === "return" || key.sequence === "\r") {
-          process.stdin.removeListener("keypress", onKey);
-          process.stdout.write("\n");
-          resolve4(options[cursor].value);
-        }
-      };
-      process.stdin.on("keypress", onKey);
-      if (process.stdin.isTTY) {
-        process.stdin.resume();
-      }
-    });
-  } finally {
-    if (process.stdin.isTTY) process.stdin.setRawMode(wasRaw ?? false);
+}
+function green(text) {
+  return `\x1B[32m${text}\x1B[0m`;
+}
+function yellow(text) {
+  return `\x1B[33m${text}\x1B[0m`;
+}
+function red(text) {
+  return `\x1B[31m${text}\x1B[0m`;
+}
+function bold(text) {
+  return `\x1B[1m${text}\x1B[0m`;
+}
+function dim(text) {
+  return `\x1B[2m${text}\x1B[0m`;
+}
+async function prompt(question) {
+  if (process.stdin.isTTY) {
+    process.stdin.removeAllListeners("keypress");
+    process.stdin.pause();
   }
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  return new Promise((resolve4) => {
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve4(answer.trim());
+    });
+  });
 }
-async function multiSelect(options, opts) {
-  if (options.length === 0) return [];
+async function select(options, opts) {
+  if (options.length === 0) throw new Error("select() requires at least one option");
+  if (options.length === 1) return options[0].value;
   const message = opts?.message ?? "";
   const wasRaw = process.stdin.isRaw;
   if (process.stdin.isTTY) process.stdin.setRawMode(true);
   try {
     let cursor = 0;
-    const selected = /* @__PURE__ */ new Set();
     const render = () => {
-      const lines = options.length + (message ? 1 : 0) + 1;
+      const lines = options.length + (message ? 1 : 0);
       process.stdout.write(`\x1B[${lines}A\x1B[0J`);
       if (message) {
         process.stdout.write(`${message}
 `);
       }
-      process.stdout.write(`${dim("  \u2191/\u2193 navigate, space to select, enter to confirm")}
-`);
       for (let i = 0; i < options.length; i++) {
         const opt = options[i];
         const prefix = i === cursor ? `${cyan("\u276F")} ` : "  ";
-        const check = selected.has(i) ? green("\u25C9") : "\u25CB";
         const label = i === cursor ? bold(opt.label) : opt.label;
-        process.stdout.write(`${prefix}${check} ${label}
-`);
-      }
-    };
-    if (message) {
-      process.stdout.write(`${message}
-`);
-    }
-    process.stdout.write(`${dim("  \u2191/\u2193 navigate, space to select, enter to confirm")}
-`);
-    for (let i = 0; i < options.length; i++) {
-      const opt = options[i];
-      const prefix = i === cursor ? `${cyan("\u276F")} ` : "  ";
-      const check = selected.has(i) ? green("\u25C9") : "\u25CB";
-      const label = i === cursor ? bold(opt.label) : opt.label;
-      process.stdout.write(`${prefix}${check} ${label}
-`);
-    }
-    return new Promise((resolve4) => {
-      const onKey = (_ch, key) => {
-        if (key.name === "up" || key.sequence === "\x1B[A") {
-          cursor = (cursor - 1 + options.length) % options.length;
-          render();
-        } else if (key.name === "down" || key.sequence === "\x1B[B") {
-          cursor = (cursor + 1) % options.length;
-          render();
-        } else if (key.name === "space") {
-          if (selected.has(cursor)) {
-            selected.delete(cursor);
-          } else {
-            selected.add(cursor);
-          }
-          render();
-        } else if (key.name === "return" || key.sequence === "\r") {
-          process.stdin.removeListener("keypress", onKey);
-          process.stdout.write("\n");
-          const result = Array.from(selected).sort((a, b) => a - b).map((i) => options[i].value);
-          resolve4(result);
-        }
-      };
-      process.stdin.on("keypress", onKey);
-      if (process.stdin.isTTY) {
-        process.stdin.resume();
-      }
-    });
-  } finally {
-    if (process.stdin.isTTY) process.stdin.setRawMode(wasRaw ?? false);
-  }
-}
-
-// src/cli/tailscale-login.ts
-async function interactiveLogin(binary) {
-  console.log(`
-${cyan("Running interactive login...")}`);
-  console.log("A browser window should open. Authenticate in the browser, then return here.\n");
-  const child = spawn2(binary, ["login"], { stdio: "inherit" });
-  const exitCode = await new Promise((resolve4) => {
-    child.on("close", resolve4);
-  });
-  resetTailscaleBinaryCache();
-  const status = getTailscaleInstallationStatus();
-  if (exitCode === 0 && status.state === "connected") {
-    console.log(`
-${green("\u2705 Login successful!")} IP: ${status.tailscale_ip}`);
-    showAuthKeyTip();
-    return true;
-  }
-  console.log(`
-${yellow("\u26A0\uFE0F  Login may not have completed. Status: " + status.state)}`);
-  console.log("  Try running: open-party login");
-  return false;
-}
-async function authKeyLogin(binary) {
-  console.log("");
-  console.log("Ask the network creator to generate an Auth Key at:");
-  console.log(`${cyan("  https://login.tailscale.com/admin/settings/keys")}
-`);
-  const authKey = await prompt("Enter Auth Key: ");
-  if (!authKey) {
-    console.log(yellow("No auth key provided, skipping login."));
-    return false;
-  }
-  const result = joinTailnet(authKey);
-  if (result.success) {
-    resetTailscaleBinaryCache();
-    const status = getTailscaleInstallationStatus();
-    console.log(`
-${green("\u2705 Login successful!")} IP: ${status.state === "connected" ? status.tailscale_ip : "unknown"}`);
-    showAuthKeyTip();
-    return true;
-  }
-  console.log(`
-${red("\u274C Login failed:")}
-${result.output}`);
-  console.log("  Check your auth key and try again.");
-  return false;
-}
-function showAuthKeyTip() {
-  console.log("");
-  console.log(`${bold("\u{1F4A1} To share network access with teammates:")}`);
-  console.log("  1. Go to https://login.tailscale.com/admin/settings/keys");
-  console.log("  2. Generate an Auth Key");
-  console.log("  3. Share it with teammates \u2014 they can run: open-party login");
-}
-
-// src/cli/setup.ts
-async function stepTailscale() {
-  console.log(`
-${bold(cyan("\u{1F50D} Step 1: Tailscale Network"))}
-`);
-  console.log(
-    "Tailscale enables agents across different machines to discover and\ncommunicate with each other over a secure network.\n"
-  );
-  console.log(
-    `${dim("Without Tailscale, Open Party runs in local mode \u2014 connecting only\nto agents on this machine.")}
-`
-  );
-  const status = getTailscaleInstallationStatus();
-  if (status.state === "connected") {
-    console.log(`${green("\u2705 Tailscale is connected!")}`);
-    console.log(`   IP: ${status.tailscale_ip}  Hostname: ${status.hostname}`);
-    return;
-  }
-  if (status.state === "not_installed") {
-    await handleNotInstalled(status.platform);
-    const newStatus = getTailscaleInstallationStatus();
-    if (newStatus.state === "not_installed") {
-      showLocalModeNotice();
-      return;
-    }
-    if (newStatus.state === "connected") {
-      console.log(`
-${green("\u2705 Tailscale is connected!")} IP: ${newStatus.tailscale_ip}`);
-      return;
-    }
-    await handleNotConnected(newStatus.binary);
-    return;
-  }
-  await handleNotConnected(status.binary);
-}
-async function handleNotInstalled(platform) {
-  const info = getInstallInstructions(platform);
-  console.log(`${red("\u274C Tailscale is not installed.")}`);
-  console.log(`
-Install Tailscale for ${bold(info.os)}:
-`);
-  if (info.commands.length > 0) {
-    for (const cmd of info.commands) {
-      const prefix = info.needs_sudo ? "sudo " : "";
-      console.log(`  ${cyan(prefix + cmd)}`);
-    }
-  }
-  console.log(`
-  Download: ${info.download_url}
-`);
-  const options = [];
-  if (info.commands.length > 0 && platform !== "win32") {
-    options.push({ label: "Install Tailscale automatically", value: "auto", hint: "recommended" });
-  }
-  options.push({ label: "I've installed Tailscale, re-detect", value: "redetect" });
-  options.push({ label: "Skip \u2014 use local mode only", value: "skip", hint: "agents on this machine only" });
-  const choice = await select(options, { message: "Choose:" });
-  if (choice === "skip") {
-    return;
-  }
-  if (choice === "auto") {
-    console.log("");
-    const result = await installTailscale(platform);
-    if (result.success) {
-      console.log(`${green("\u2705 Tailscale installed successfully!")}`);
-    } else {
-      console.log(`${red("\u274C Installation failed:")}
-${result.output}`);
-      console.log(`
-  Please install manually and re-run: ${cyan("open-party setup")}`);
-    }
-    return;
-  }
-  if (choice === "redetect") {
-    resetTailscaleBinaryCache();
-    return;
-  }
-}
-async function handleNotConnected(binary) {
-  console.log(`${yellow("\u{1F512} Tailscale is installed but not connected.")}
-`);
-  const options = [
-    { label: "Interactive login", value: "interactive", hint: "opens browser to authenticate" },
-    { label: "Auth key", value: "authkey", hint: "from network creator" },
-    { label: "Skip", value: "skip", hint: "login later with: open-party login" }
-  ];
-  const choice = await select(options, { message: "Choose a login method:" });
-  if (choice === "interactive") {
-    await interactiveLogin(binary);
-  } else if (choice === "authkey") {
-    await authKeyLogin(binary);
-  } else {
-    console.log(`
-${yellow("\u26A0\uFE0F  Tailscale not connected. Running in local mode.")}`);
-    console.log(`   To connect later, run: ${cyan("open-party login")}`);
-  }
-}
-function showLocalModeNotice() {
-  console.log(`
-${yellow("\u26A0\uFE0F  Running in local mode \u2014 connecting to agents on this machine only.")}`);
-  console.log("   To enable cross-machine communication later:");
-  console.log(`     1. Install Tailscale: ${cyan("https://tailscale.com/download")}`);
-  console.log(`     2. Run: ${cyan("open-party login")}`);
-}
-async function stepAgentPlugin() {
-  console.log(`
-${bold(cyan("\u{1F50D} Step 2: Detecting AI agents in your environment..."))}
+        const hintStr = opt.hint ? ` ${dim(opt.hint)}` : "";
+        process.stdout.write(`${prefix}${label}${hintStr}
 `);
-  const agents = detectAgents();
-  const detected = agents.filter((a) => a.detected);
-  if (detected.length === 0) {
-    console.log(yellow("No supported AI agents detected in this environment."));
-    console.log("  Supported agents: Claude Code, OpenClaw");
-    console.log("");
-    console.log("  Install one and re-run: open-party setup");
-    return;
-  }
-  console.log("Detected agents:\n");
-  for (const agent of detected) {
-    console.log(`  ${green("\u2713")} ${agent.name}`);
-  }
-  console.log("");
-  const options = detected.map((a) => ({ label: a.name, value: a }));
-  const selected = await multiSelect(options, {
-    message: "Select agents to install Open Party plugin:"
-  });
-  if (selected.length === 0) {
-    console.log(yellow("No agents selected, skipping plugin installation."));
-    return;
-  }
-  for (const agent of selected) {
-    console.log(`
-Installing Open Party plugin for ${agent.name}...`);
-    const result = await installPluginToAgent(agent.type);
-    if (result.success) {
-      console.log(`${green("\u2705")} Plugin installed for ${agent.name}${result.configPath ? ` (${result.configPath})` : ""}`);
-      if (result.warning) {
-        console.log(`  ${yellow("\u26A0\uFE0F")} ${result.warning}`);
-      }
-      if (agent.type === "claude-code") {
-        console.log(`  ${bold("Please restart Claude Code")} for changes to take effect.`);
-      }
-      if (agent.type === "openclaw") {
-        console.log(`  ${bold("Please restart OpenClaw gateway")} for changes to take effect.`);
       }
-    } else {
-      console.log(`${red("\u274C")} Failed to install for ${agent.name}: ${result.error}`);
-    }
-  }
-}
-async function setupCommand() {
-  console.log(bold(cyan("\n\u{1F680} Open Party Setup Wizard\n")));
-  const rl = createRl();
-  await stepTailscale();
-  await stepAgentPlugin();
-  console.log(`
-${bold(cyan("\u{1F680} Starting Party Server..."))}`);
-  const { spawn: spawn4 } = await import("child_process");
-  const { resolve: resolve4, dirname: dirname6 } = await import("path");
-  const { fileURLToPath: fileURLToPath3 } = await import("url");
-  const __dirname2 = dirname6(fileURLToPath3(import.meta.url));
-  const serverScript = resolve4(__dirname2, "..", "party-server.js");
-  const serverProc = spawn4(process.execPath, [serverScript], {
-    detached: true,
-    stdio: "ignore",
-    windowsHide: true
-  });
-  serverProc.unref();
-  await new Promise((r) => setTimeout(r, 2e3));
-  console.log(`
-${bold(green("\u{1F389} Setup complete!"))}`);
-  console.log(`  Dashboard: http://127.0.0.1:8000/dashboard`);
-  console.log("  Other agents can join with: npx @feynmanzhang/open-party setup\n");
-  closeRl(rl);
-}
-
-// src/cli/login.ts
-init_tailscale();
-async function loginCommand() {
-  const status = getTailscaleInstallationStatus();
-  if (status.state === "connected") {
-    console.log(`${green("\u2705 Tailscale is already connected!")}`);
-    console.log(`   IP: ${status.tailscale_ip}  Hostname: ${status.hostname}`);
-    return;
-  }
-  if (status.state === "not_installed") {
-    console.log(`${red("\u274C Tailscale is not installed.")}`);
-    console.log("  Install it first: https://tailscale.com/download");
-    console.log(`  Then run: ${cyan("open-party login")}`);
-    return;
-  }
-  console.log(`${yellow("\u{1F512} Tailscale is installed but not connected.")}
-`);
-  const options = [
-    { label: "Interactive login", value: "interactive", hint: "opens browser to authenticate" },
-    { label: "Auth key", value: "authkey", hint: "from network creator" }
-  ];
-  const choice = await select(options, { message: "Choose a login method:" });
-  if (choice === "interactive") {
-    await interactiveLogin(status.binary);
-  } else {
-    await authKeyLogin(status.binary);
-  }
-}
-
-// src/cli/logout.ts
-init_tailscale();
-async function logoutCommand() {
-  const status = getTailscaleInstallationStatus();
-  if (status.state === "not_installed") {
-    console.log(red("\u274C Tailscale is not installed."));
-    return;
-  }
-  if (status.state === "not_connected") {
-    console.log(yellow("\u26A0\uFE0F  Tailscale is not connected \u2014 nothing to log out from."));
-    return;
-  }
-  const choice = await select(
-    [
-      { label: "Log out (remove credentials)", value: "logout", hint: "need to re-authenticate next time" },
-      { label: "Cancel", value: "cancel" }
-    ],
-    { message: "Are you sure you want to log out?" }
-  );
-  if (choice === "cancel") return;
-  console.log("Logging out of Tailscale...");
-  const result = logoutTailscale();
-  if (result.success) {
-    console.log(green("\u2705 Logged out successfully."));
-    console.log("  To reconnect, run: open-party login");
-  } else {
-    console.log(red("\u274C Logout failed:"), result.output);
+    };
+    if (message) {
+      process.stdout.write(`${message}
+`);
+    }
+    for (let i = 0; i < options.length; i++) {
+      const opt = options[i];
+      const prefix = i === cursor ? `${cyan("\u276F")} ` : "  ";
+      const label = i === cursor ? bold(opt.label) : opt.label;
+      const hintStr = opt.hint ? ` ${dim(opt.hint)}` : "";
+      process.stdout.write(`${prefix}${label}${hintStr}
+`);
+    }
+    return new Promise((resolve4) => {
+      const onKey = (ch, key) => {
+        if (key.name === "up" || key.sequence === "\x1B[A") {
+          cursor = (cursor - 1 + options.length) % options.length;
+          render();
+        } else if (key.name === "down" || key.sequence === "\x1B[B") {
+          cursor = (cursor + 1) % options.length;
+          render();
+        } else if (key.name === "return" || key.sequence === "\r") {
+          process.stdin.removeListener("keypress", onKey);
+          process.stdout.write("\n");
+          resolve4(options[cursor].value);
+        }
+      };
+      process.stdin.on("keypress", onKey);
+      if (process.stdin.isTTY) {
+        process.stdin.resume();
+      }
+    });
+  } finally {
+    if (process.stdin.isTTY) process.stdin.setRawMode(wasRaw ?? false);
   }
 }
 
 // src/cli/server-utils.ts
-import { spawn as spawn3, execSync as execSync3 } from "child_process";
-import { existsSync as existsSync4, readFileSync as readFileSync2, writeFileSync as writeFileSync2, unlinkSync, mkdirSync as mkdirSync2, openSync } from "fs";
-import { join as join4, dirname as dirname2, resolve as resolve2 } from "path";
-import { homedir as homedir3 } from "os";
+import { spawn, execSync } from "child_process";
+import { existsSync, readFileSync, writeFileSync, unlinkSync, mkdirSync, openSync } from "fs";
+import { join, dirname, resolve } from "path";
+import { homedir } from "os";
 import { fileURLToPath } from "url";
-var __dirname = dirname2(fileURLToPath(import.meta.url));
+var __dirname = dirname(fileURLToPath(import.meta.url));
 function pidFilePath() {
   const pluginData = process.env.CLAUDE_PLUGIN_DATA || "";
-  if (pluginData) return join4(pluginData, "server.pid");
-  return join4(homedir3(), ".open-party", "server.pid");
+  if (pluginData) return join(pluginData, "server.pid");
+  return join(homedir(), ".open-party", "server.pid");
 }
 function logFilePath() {
   const pluginData = process.env.CLAUDE_PLUGIN_DATA || "";
-  if (pluginData) return join4(pluginData, "server.log");
-  return join4(homedir3(), ".open-party", "server.log");
+  if (pluginData) return join(pluginData, "server.log");
+  return join(homedir(), ".open-party", "server.log");
 }
 function serverScriptPath() {
-  return resolve2(__dirname, "..", "party-server.js");
+  return resolve(__dirname, "..", "party-server.js");
 }
 function readPid() {
   const path = pidFilePath();
-  if (!existsSync4(path)) return null;
+  if (!existsSync(path)) return null;
   try {
-    return parseInt(readFileSync2(path, "utf-8").trim(), 10);
+    return parseInt(readFileSync(path, "utf-8").trim(), 10);
   } catch {
     return null;
   }
 }
 function writePid(pid) {
   const path = pidFilePath();
-  const dir = dirname2(path);
-  if (!existsSync4(dir)) mkdirSync2(dir, { recursive: true });
-  writeFileSync2(path, String(pid));
+  const dir = dirname(path);
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+  writeFileSync(path, String(pid));
 }
 function removePidFile() {
   try {
@@ -6599,7 +4729,7 @@ function removePidFile() {
 function isProcessRunning(pid) {
   if (process.platform === "win32") {
     try {
-      const output2 = execSync3(`tasklist /FI "PID eq ${pid}" /NH`, {
+      const output2 = execSync(`tasklist /FI "PID eq ${pid}" /NH`, {
         encoding: "utf-8",
         windowsHide: true,
         stdio: ["pipe", "pipe", "pipe"]
@@ -6646,15 +4776,15 @@ async function getServerOverview(port) {
 }
 async function spawnServerInBackground(port) {
   const script = serverScriptPath();
-  if (!existsSync4(script)) {
+  if (!existsSync(script)) {
     console.error(`Server script not found: ${script}`);
     return { pid: 0, ok: false };
   }
   const logPath = logFilePath();
-  mkdirSync2(dirname2(logPath), { recursive: true });
+  mkdirSync(dirname(logPath), { recursive: true });
   const logFd = openSync(logPath, "a");
   const env = { ...process.env, PARTY_PORT: String(port) };
-  const proc = spawn3(process.execPath, [script], {
+  const proc = spawn(process.execPath, [script], {
     stdio: ["ignore", logFd, logFd],
     detached: true,
     windowsHide: true,
@@ -6678,56 +4808,356 @@ async function waitForServerReady(port, timeoutMs = 1e4) {
     }
     await sleep(500);
   }
-  return false;
+  return false;
+}
+function killServer(pid) {
+  try {
+    if (process.platform === "win32") {
+      execSync(`taskkill /F /T /PID ${pid}`, { stdio: "ignore", windowsHide: true });
+    } else {
+      process.kill(pid, "SIGTERM");
+    }
+  } catch (error) {
+    void error;
+  }
+}
+function findPidByPort(port) {
+  try {
+    if (process.platform === "win32") {
+      const output3 = execSync(
+        `netstat -ano -p tcp | findstr "LISTENING" | findstr ":${port} "`,
+        { encoding: "utf-8", windowsHide: true, stdio: ["pipe", "pipe", "pipe"] }
+      );
+      const match2 = output3.trim().match(/\s(\d+)\s*$/);
+      return match2 ? parseInt(match2[1], 10) : null;
+    }
+    const output2 = execSync(`lsof -t -i :${port} -sTCP:LISTEN`, {
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    const pid = parseInt(output2.trim().split("\n")[0], 10);
+    return Number.isFinite(pid) && pid > 0 ? pid : null;
+  } catch {
+    return null;
+  }
+}
+function extractFlagValue(args2, flag) {
+  for (let i = 0; i < args2.length; i++) {
+    if (args2[i] === flag) return args2[i + 1];
+  }
+  return void 0;
+}
+function parseStartArgs(args2) {
+  let daemon = false;
+  let port = null;
+  for (let i = 0; i < args2.length; i++) {
+    if (args2[i] === "-d" || args2[i] === "--daemon") {
+      daemon = true;
+    } else if (args2[i] === "-p" || args2[i] === "--port") {
+      const val = args2[++i];
+      if (val) port = parseInt(val, 10);
+    } else if (args2[i].startsWith("--port=")) {
+      port = parseInt(args2[i].split("=")[1], 10);
+    }
+  }
+  return { daemon, port };
+}
+function sleep(ms) {
+  return new Promise((resolve4) => setTimeout(resolve4, ms));
+}
+
+// src/cli/setup.ts
+var IS_WIN = platform() === "win32";
+var ROOT = resolve2(import.meta.dirname ?? ".", "..", "..");
+function sh(cmd) {
+  execSync2(cmd, { stdio: "inherit", shell: IS_WIN });
+}
+function safeRm(target) {
+  if (!existsSync2(target)) return;
+  if (IS_WIN) {
+    const isDir = statSync(target).isDirectory();
+    sh(isDir ? `rd /s /q "${target}"` : `del /f /q "${target}"`);
+  } else {
+    sh(`rm -rf "${target}"`);
+  }
+}
+function safeCp(src, dst) {
+  ensureDir(dst);
+  if (IS_WIN) {
+    const isDir = statSync(src).isDirectory();
+    sh(isDir ? `xcopy "${src}" "${dst}\\" /E /I /Y /Q >nul 2>&1` : `copy /y "${src}" "${dst}" >nul 2>&1`);
+  } else {
+    sh(`cp -r "${src}" "${dst}"`);
+  }
+}
+function ensureDir(filePath) {
+  const dir = dirname2(filePath);
+  if (!existsSync2(dir)) mkdirSync2(dir, { recursive: true });
+}
+function readJsonFile(filePath, fallback) {
+  if (!existsSync2(filePath)) return fallback;
+  try {
+    return JSON.parse(readFileSync2(filePath, "utf-8"));
+  } catch {
+    return fallback;
+  }
+}
+function writeJsonFile(filePath, data) {
+  ensureDir(filePath);
+  writeFileSync2(filePath, JSON.stringify(data, null, 2) + "\n");
+}
+function findPluginDistDir() {
+  const distDir = join2(ROOT, "dist", "claude-code");
+  if (!existsSync2(distDir)) return null;
+  try {
+    const entries = readdirSync(distDir);
+    const dirs = entries.filter((e) => e.startsWith("open-party-"));
+    if (dirs.length === 0) return null;
+    const pluginDir = join2(distDir, dirs[dirs.length - 1]);
+    if (existsSync2(join2(pluginDir, ".claude-plugin", "plugin.json"))) return pluginDir;
+  } catch {
+  }
+  return null;
+}
+function getPluginVersion(pluginDir) {
+  const manifest = readJsonFile(join2(pluginDir, ".claude-plugin", "plugin.json"), {});
+  if (manifest.version) return manifest.version;
+  try {
+    const pkg = JSON.parse(readFileSync2(join2(ROOT, "package.json"), "utf-8"));
+    if (pkg.version) return pkg.version;
+  } catch {
+  }
+  return "0.0.0";
+}
+function installToClaudeCode() {
+  const pluginDir = findPluginDistDir();
+  if (!pluginDir) {
+    console.log(`${red('Plugin package not found. Run "npm run build:plugin" first.')}`);
+    return false;
+  }
+  const version = getPluginVersion(pluginDir);
+  console.log(`Installing Open Party v${version} into Claude Code...
+`);
+  const installDir = join2(homedir2(), ".claude", "plugins", "cache", "open-party", "open-party", version);
+  if (existsSync2(installDir)) safeRm(installDir);
+  mkdirSync2(installDir, { recursive: true });
+  safeCp(pluginDir, installDir);
+  registerMarketplace(version, pluginDir);
+  const pluginsJsonPath = join2(homedir2(), ".claude", "plugins", "installed_plugins.json");
+  const pluginsData = readJsonFile(
+    pluginsJsonPath,
+    { version: 2, plugins: {} }
+  );
+  if (!pluginsData.plugins) pluginsData.plugins = {};
+  delete pluginsData.plugins["open-party@local"];
+  pluginsData.plugins["open-party@open-party"] = [{
+    scope: "user",
+    installPath: installDir,
+    version,
+    installedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    lastUpdated: (/* @__PURE__ */ new Date()).toISOString()
+  }];
+  writeJsonFile(pluginsJsonPath, pluginsData);
+  const settingsPath = join2(homedir2(), ".claude", "settings.json");
+  const settings = readJsonFile(settingsPath, {});
+  if (settings.mcpServers?.["open-party"]) {
+    delete settings.mcpServers["open-party"];
+  }
+  if (!settings.enabledPlugins) settings.enabledPlugins = {};
+  delete settings.enabledPlugins["open-party@local"];
+  settings.enabledPlugins["open-party@open-party"] = true;
+  writeJsonFile(settingsPath, settings);
+  console.log(`${green("Plugin installed successfully.")}`);
+  console.log(`  Path: ${installDir}
+`);
+  return true;
+}
+function registerMarketplace(version, pluginDir) {
+  const marketplaceDir = join2(homedir2(), ".claude", "plugins", "marketplaces", "open-party");
+  const marketplacePluginDir = join2(marketplaceDir, ".claude-plugin");
+  if (!existsSync2(marketplacePluginDir)) mkdirSync2(marketplacePluginDir, { recursive: true });
+  writeJsonFile(join2(marketplacePluginDir, "marketplace.json"), {
+    name: "open-party",
+    owner: { name: "Feynman Zhang" },
+    metadata: {
+      description: "Decentralized Agent communication network for Claude Code",
+      homepage: "https://github.com/FeynmanZhang/open-party"
+    },
+    plugins: [{
+      name: "open-party",
+      version,
+      source: "./plugin",
+      description: "Decentralized Agent communication network for Claude Code"
+    }]
+  });
+  const pluginSourceDir = join2(marketplaceDir, "plugin");
+  if (existsSync2(pluginSourceDir)) safeRm(pluginSourceDir);
+  mkdirSync2(pluginSourceDir, { recursive: true });
+  safeCp(pluginDir, pluginSourceDir);
+  const knownPath = join2(homedir2(), ".claude", "plugins", "known_marketplaces.json");
+  const known = readJsonFile(knownPath, {});
+  known["open-party"] = {
+    source: { source: "github", repo: "FeynmanZhang/open-party" },
+    installLocation: marketplaceDir,
+    lastUpdated: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  writeJsonFile(knownPath, known);
+}
+function buildPlugin() {
+  console.log(`${bold(cyan("Building plugin..."))}
+`);
+  try {
+    execSync2("node scripts/build-plugin.mjs", { cwd: ROOT, stdio: "inherit" });
+    return true;
+  } catch {
+    console.log(`${red("Build failed.")}`);
+    return false;
+  }
+}
+async function setupCommand() {
+  console.log(`
+${bold(cyan("Open Party Setup"))}
+`);
+  if (!buildPlugin()) {
+    process.exit(1);
+  }
+  if (!installToClaudeCode()) {
+    process.exit(1);
+  }
+  console.log(`${bold(cyan("Starting Party Server..."))}
+`);
+  const port = resolvePort([]);
+  try {
+    spawnServerInBackground(port);
+    await waitForServerReady(port, 15e3);
+    console.log(`${green("Party Server started on port " + port)}.
+`);
+  } catch (error) {
+    console.log(`${red("Failed to start Party Server:")} ${error instanceof Error ? error.message : String(error)}`);
+    console.log("  You can start it manually with: open-party start");
+  }
+  console.log(`${green("Setup complete!")}`);
+  console.log("  Restart Claude Code to load the plugin.");
+  console.log(`  Use ${cyan("open-party agents")} to see who's online.
+`);
+}
+
+// src/cli/login.ts
+init_tailscale();
+
+// src/cli/tailscale-login.ts
+init_tailscale();
+import { spawn as spawn2 } from "child_process";
+async function interactiveLogin(binary) {
+  console.log(`
+${cyan("Running interactive login...")}`);
+  console.log("A browser window should open. Authenticate in the browser, then return here.\n");
+  const child = spawn2(binary, ["login"], { stdio: "inherit" });
+  const exitCode = await new Promise((resolve4) => {
+    child.on("close", resolve4);
+  });
+  resetTailscaleBinaryCache();
+  const status = getTailscaleInstallationStatus();
+  if (exitCode === 0 && status.state === "connected") {
+    console.log(`
+${green("\u2705 Login successful!")} IP: ${status.tailscale_ip}`);
+    showAuthKeyTip();
+    return true;
+  }
+  console.log(`
+${yellow("\u26A0\uFE0F  Login may not have completed. Status: " + status.state)}`);
+  console.log("  Try running: open-party login");
+  return false;
+}
+async function authKeyLogin(binary) {
+  console.log("");
+  console.log("Ask the network creator to generate an Auth Key at:");
+  console.log(`${cyan("  https://login.tailscale.com/admin/settings/keys")}
+`);
+  const authKey = await prompt("Enter Auth Key: ");
+  if (!authKey) {
+    console.log(yellow("No auth key provided, skipping login."));
+    return false;
+  }
+  const result = joinTailnet(authKey);
+  if (result.success) {
+    resetTailscaleBinaryCache();
+    const status = getTailscaleInstallationStatus();
+    console.log(`
+${green("\u2705 Login successful!")} IP: ${status.state === "connected" ? status.tailscale_ip : "unknown"}`);
+    showAuthKeyTip();
+    return true;
+  }
+  console.log(`
+${red("\u274C Login failed:")}
+${result.output}`);
+  console.log("  Check your auth key and try again.");
+  return false;
+}
+function showAuthKeyTip() {
+  console.log("");
+  console.log(`${bold("\u{1F4A1} To share network access with teammates:")}`);
+  console.log("  1. Go to https://login.tailscale.com/admin/settings/keys");
+  console.log("  2. Generate an Auth Key");
+  console.log("  3. Share it with teammates \u2014 they can run: open-party login");
+}
+
+// src/cli/login.ts
+async function loginCommand() {
+  const status = getTailscaleInstallationStatus();
+  if (status.state === "connected") {
+    console.log(`${green("\u2705 Tailscale is already connected!")}`);
+    console.log(`   IP: ${status.tailscale_ip}  Hostname: ${status.hostname}`);
+    return;
+  }
+  if (status.state === "not_installed") {
+    console.log(`${red("\u274C Tailscale is not installed.")}`);
+    console.log("  Install it first: https://tailscale.com/download");
+    console.log(`  Then run: ${cyan("open-party login")}`);
+    return;
+  }
+  console.log(`${yellow("\u{1F512} Tailscale is installed but not connected.")}
+`);
+  const options = [
+    { label: "Interactive login", value: "interactive", hint: "opens browser to authenticate" },
+    { label: "Auth key", value: "authkey", hint: "from network creator" }
+  ];
+  const choice = await select(options, { message: "Choose a login method:" });
+  if (choice === "interactive") {
+    await interactiveLogin(status.binary);
+  } else {
+    await authKeyLogin(status.binary);
+  }
 }
-function killServer(pid) {
-  try {
-    if (process.platform === "win32") {
-      execSync3(`taskkill /F /T /PID ${pid}`, { stdio: "ignore", windowsHide: true });
-    } else {
-      process.kill(pid, "SIGTERM");
-    }
-  } catch (error) {
-    void error;
+
+// src/cli/logout.ts
+init_tailscale();
+async function logoutCommand() {
+  const status = getTailscaleInstallationStatus();
+  if (status.state === "not_installed") {
+    console.log(red("\u274C Tailscale is not installed."));
+    return;
   }
-}
-function findPidByPort(port) {
-  try {
-    if (process.platform === "win32") {
-      const output3 = execSync3(
-        `netstat -ano -p tcp | findstr "LISTENING" | findstr ":${port} "`,
-        { encoding: "utf-8", windowsHide: true, stdio: ["pipe", "pipe", "pipe"] }
-      );
-      const match2 = output3.trim().match(/\s(\d+)\s*$/);
-      return match2 ? parseInt(match2[1], 10) : null;
-    }
-    const output2 = execSync3(`lsof -t -i :${port} -sTCP:LISTEN`, {
-      encoding: "utf-8",
-      stdio: ["pipe", "pipe", "pipe"]
-    });
-    const pid = parseInt(output2.trim().split("\n")[0], 10);
-    return Number.isFinite(pid) && pid > 0 ? pid : null;
-  } catch {
-    return null;
+  if (status.state === "not_connected") {
+    console.log(yellow("\u26A0\uFE0F  Tailscale is not connected \u2014 nothing to log out from."));
+    return;
   }
-}
-function parseStartArgs(args2) {
-  let daemon = false;
-  let port = null;
-  for (let i = 0; i < args2.length; i++) {
-    if (args2[i] === "-d" || args2[i] === "--daemon") {
-      daemon = true;
-    } else if (args2[i] === "-p" || args2[i] === "--port") {
-      const val = args2[++i];
-      if (val) port = parseInt(val, 10);
-    } else if (args2[i].startsWith("--port=")) {
-      port = parseInt(args2[i].split("=")[1], 10);
-    }
+  const choice = await select(
+    [
+      { label: "Log out (remove credentials)", value: "logout", hint: "need to re-authenticate next time" },
+      { label: "Cancel", value: "cancel" }
+    ],
+    { message: "Are you sure you want to log out?" }
+  );
+  if (choice === "cancel") return;
+  console.log("Logging out of Tailscale...");
+  const result = logoutTailscale();
+  if (result.success) {
+    console.log(green("\u2705 Logged out successfully."));
+    console.log("  To reconnect, run: open-party login");
+  } else {
+    console.log(red("\u274C Logout failed:"), result.output);
   }
-  return { daemon, port };
-}
-function sleep(ms) {
-  return new Promise((resolve4) => setTimeout(resolve4, ms));
 }
 
 // src/cli/start-server.ts
@@ -6908,52 +5338,142 @@ function showVersion() {
   console.log(`open-party v${pkg.version}`);
 }
 
-// src/cli/agents.ts
-async function agentsCommand() {
-  const port = resolvePort();
-  if (!await isServerHealthy(port)) {
-    console.log("Party Server is not running.");
-    console.log("  Use 'open-party start' to start it.");
-    return;
+// src/client/shared/client.ts
+var PartyHttpClient = class {
+  baseUrl;
+  timeout;
+  constructor(baseUrl = "http://127.0.0.1:8000", timeout = 5e3) {
+    this.baseUrl = baseUrl.replace(/\/$/, "");
+    this.timeout = timeout;
   }
-  const overview = await getServerOverview(port);
-  if (!overview) {
-    console.log("Failed to get server overview.");
-    return;
+  // -- Dashboard --
+  async getOverview() {
+    return this.request("/dashboard/api/overview");
+  }
+  async request(path, options = {}) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), this.timeout);
+    try {
+      const resp = await fetch(`${this.baseUrl}${path}`, {
+        ...options,
+        signal: controller.signal,
+        headers: {
+          "Content-Type": "application/json",
+          ...options.headers
+        }
+      });
+      if (!resp.ok) throw new Error(`HTTP ${resp.status}: ${resp.statusText}`);
+      return resp.json();
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+  // -- Agent lifecycle --
+  async register(agentId, displayName, metadata, callbackUrl) {
+    return this.request("/agent/register", {
+      method: "POST",
+      body: JSON.stringify({ agent_id: agentId, display_name: displayName, metadata: metadata ?? {}, callback_url: callbackUrl })
+    });
+  }
+  async remove(agentId) {
+    const result = await this.request("/agent/remove", {
+      method: "POST",
+      body: JSON.stringify({ agent_id: agentId })
+    });
+    return result.status === "removed";
   }
-  const agents = overview.agents;
-  if (!agents) {
-    console.log("No agent data available.");
+  async heartbeat(agentId, displayName, metadata, callbackUrl) {
+    return this.request("/agent/heartbeat", {
+      method: "POST",
+      body: JSON.stringify({ agent_id: agentId, display_name: displayName, metadata, callback_url: callbackUrl })
+    });
+  }
+  async listAgents() {
+    const result = await this.request("/agent/list");
+    return result.agents ?? [];
+  }
+  // -- Messaging --
+  async sendMessage(senderId, recipientId, content, summary) {
+    return this.request("/agent/send", {
+      method: "POST",
+      body: JSON.stringify({ sender_id: senderId, recipient_id: recipientId, content, summary })
+    });
+  }
+  async checkMessages(agentId) {
+    const result = await this.request(`/agent/messages/${agentId}`);
+    return result.messages ?? [];
+  }
+  /** Get message history for an agent. */
+  async getMessageHistory(agentId, limit = 20) {
+    const result = await this.request(`/agent/history/${agentId}?limit=${limit}`);
+    return result.history ?? [];
+  }
+  // -- Proxy --
+  async health() {
+    return this.request("/proxy/health");
+  }
+};
+
+// src/cli/list-agents.ts
+async function listAgentsCommand(args2) {
+  const jsonMode = args2.includes("--json");
+  const client = new PartyHttpClient();
+  try {
+    await client.health();
+  } catch {
+    console.log("Party Server is not running.");
+    console.log("  Use 'open-party start' to start it.");
     return;
   }
-  const localAgents = agents.local_agents ?? [];
-  const remoteAgents = agents.remote_agents ?? [];
-  const localCount = agents.local_count ?? localAgents.length;
-  const remoteCount = agents.remote_count ?? remoteAgents.length;
-  if (localCount === 0) {
-    console.log("Local agents: (none)");
-  } else {
-    console.log(`Local agents (${localCount}):`);
-    for (const agent of localAgents) {
-      const id = agent.agent_id ?? "?";
-      const name = agent.display_name ?? id;
-      const ago = formatTimeAgo(agent.last_heartbeat);
-      console.log(`  ${id.padEnd(20)} ${name.padEnd(16)} ${ago}`);
+  try {
+    const overview = await client.getOverview();
+    const agentsData = overview.agents;
+    if (!agentsData) {
+      console.log("No agent data available.");
+      return;
     }
-  }
-  if (remoteCount > 0) {
-    console.log(`
+    const localAgents = agentsData.local_agents ?? [];
+    const remoteAgents = agentsData.remote_agents ?? [];
+    const localCount = agentsData.local_count ?? localAgents.length;
+    const remoteCount = agentsData.remote_count ?? remoteAgents.length;
+    const allAgents = [...localAgents, ...remoteAgents];
+    const totalCount = localCount + remoteCount;
+    if (jsonMode) {
+      console.log(JSON.stringify({ agents: allAgents, count: totalCount, local_count: localCount, remote_count: remoteCount }, null, 2));
+      return;
+    }
+    if (totalCount === 0) {
+      console.log("No agents currently online.");
+      return;
+    }
+    if (localCount === 0) {
+      console.log("Local agents: (none)");
+    } else {
+      console.log(`Local agents (${localCount}):`);
+      for (const agent of localAgents) {
+        const id = agent.agent_id ?? "?";
+        const name = agent.display_name ?? id;
+        const ago = formatTimeAgo(agent.last_heartbeat);
+        console.log(`  ${id.padEnd(20)} ${name.padEnd(16)} ${ago}`);
+      }
+    }
+    if (remoteCount > 0) {
+      console.log(`
 Remote agents (${remoteCount}):`);
-    for (const agent of remoteAgents) {
-      const id = agent.agent_id ?? "?";
-      const name = agent.display_name ?? id;
-      const via = agent.source_peer_ip ?? "?";
-      const ago = formatTimeAgo(agent.last_heartbeat);
-      console.log(`  ${id.padEnd(20)} ${name.padEnd(16)} (via ${via})  ${ago}`);
+      for (const agent of remoteAgents) {
+        const id = agent.agent_id ?? "?";
+        const name = agent.display_name ?? id;
+        const via = agent.source_peer_ip ?? "?";
+        const ago = formatTimeAgo(agent.last_heartbeat);
+        console.log(`  ${id.padEnd(20)} ${name.padEnd(16)} (via ${via})  ${ago}`);
+      }
     }
-  }
-  if (localCount === 0 && remoteCount === 0) {
-    console.log("\nNo agents connected yet.");
+    console.log("");
+    console.log("Tip: Use `open-party send-message --recipient <id>` to reach any agent above.");
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    console.error(`Error: ${msg}`);
+    process.exit(1);
   }
 }
 function formatTimeAgo(timestamp) {
@@ -6966,118 +5486,465 @@ function formatTimeAgo(timestamp) {
 }
 
 // src/cli/peers.ts
-async function peersCommand() {
-  const port = resolvePort();
-  if (!await isServerHealthy(port)) {
+async function peersCommand(args2 = []) {
+  const jsonMode = args2.includes("--json");
+  const client = new PartyHttpClient();
+  try {
+    await client.health();
+  } catch {
     console.log("Party Server is not running.");
     console.log("  Use 'open-party start' to start it.");
     return;
   }
-  const overview = await getServerOverview(port);
-  if (!overview) {
-    console.log("Failed to get server overview.");
-    return;
-  }
-  const peers = overview.peers;
-  if (!peers) {
-    console.log("No peer data available.");
-    return;
-  }
-  const details = peers.details ?? [];
-  const remoteAgents = overview.agents?.remote_agents ?? [];
-  const peerAgentCounts = /* @__PURE__ */ new Map();
-  for (const agent of remoteAgents) {
-    const ip = agent.source_peer_ip;
-    peerAgentCounts.set(ip, (peerAgentCounts.get(ip) ?? 0) + 1);
-  }
-  const total = peers.total ?? details.length;
-  if (details.length === 0) {
-    console.log("No peers discovered yet.");
-    return;
-  }
-  console.log(`Peers (${total}):
+  try {
+    const overview = await client.getOverview();
+    const peers = overview.peers;
+    if (!peers) {
+      console.log("No peer data available.");
+      return;
+    }
+    const details = peers.details ?? [];
+    const remoteAgents = overview.agents?.remote_agents ?? [];
+    const peerAgentCounts = /* @__PURE__ */ new Map();
+    for (const agent of remoteAgents) {
+      const ip = agent.source_peer_ip;
+      peerAgentCounts.set(ip, (peerAgentCounts.get(ip) ?? 0) + 1);
+    }
+    const total = peers.total ?? details.length;
+    if (jsonMode) {
+      console.log(JSON.stringify({
+        peers: details.map((p) => ({
+          ...p,
+          agent_count: peerAgentCounts.get(p.ip) ?? 0
+        })),
+        total
+      }, null, 2));
+      return;
+    }
+    if (details.length === 0) {
+      console.log("No peers discovered yet.");
+      return;
+    }
+    console.log(`Peers (${total}):
 `);
-  for (const peer of details) {
-    const agentCount = peerAgentCounts.get(peer.ip);
-    const agentStr = agentCount != null ? String(agentCount) : "\u2014";
-    const statusStr = formatStatus(peer.status);
-    console.log(`  ${peer.ip.padEnd(18)} ${statusStr.padEnd(16)} ${agentStr} agents`);
+    for (const peer of details) {
+      const agentCount = peerAgentCounts.get(peer.ip);
+      const agentStr = agentCount != null ? String(agentCount) : "\u2014";
+      const statusStr = formatStatus(peer.status);
+      console.log(`  ${peer.ip.padEnd(18)} ${statusStr.padEnd(16)} ${agentStr} agents`);
+    }
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    console.error(`Error: ${msg}`);
+    process.exit(1);
   }
 }
 function formatStatus(status) {
   const map = {
-    PARTY_SERVER: "Online",
-    DEGRADED: "Degraded",
-    SUSPECT: "Suspect",
-    DOWN: "Down",
-    UNKNOWN: "Unknown",
-    MAYBE: "Probing",
-    NOT_SERVER: "Not a server"
+    ALIVE: "Online",
+    DEAD: "Down",
+    UNKNOWN: "Unknown"
   };
   return map[status] ?? status;
 }
 
-// src/cli/install.ts
-init_tailscale();
-init_tailscale_installer();
-async function installCommand() {
-  const status = getTailscaleInstallationStatus();
-  if (status.state === "connected" || status.state === "not_connected") {
-    console.log(green("\u2705 Tailscale is already installed!"), `Binary: ${status.binary}`);
-    if (status.state === "connected") {
-      console.log(`   IP: ${status.tailscale_ip}  Hostname: ${status.hostname}`);
+// src/cli/identity.ts
+import { existsSync as existsSync8, readdirSync as readdirSync4, readFileSync as readFileSync6, statSync as statSync3 } from "fs";
+import { join as join8 } from "path";
+
+// src/client/shared/session-store.ts
+import { existsSync as existsSync7, mkdirSync as mkdirSync6, readFileSync as readFileSync5, readdirSync as readdirSync3, unlinkSync as unlinkSync5, writeFileSync as writeFileSync5 } from "fs";
+import { join as join7 } from "path";
+import { homedir as homedir6 } from "os";
+var SESSION_DIR = join7(homedir6(), ".open-party");
+var SESSIONS_DIR = join7(SESSION_DIR, "sessions");
+var AGENTS_DIR = join7(SESSION_DIR, "agents");
+function updateOnlineStatus(agentId, online) {
+  const session = readSessionByAgent(agentId);
+  if (!session) return;
+  const sessionId = session.session_id;
+  const path = join7(SESSIONS_DIR, `${sessionId}.json`);
+  if (!existsSync7(path)) return;
+  const data = JSON.parse(readFileSync5(path, "utf-8"));
+  data.online = online;
+  writeFileSync5(path, JSON.stringify(data));
+}
+function readSession(sessionId) {
+  const path = join7(SESSIONS_DIR, `${sessionId}.json`);
+  if (!existsSync7(path)) return void 0;
+  return JSON.parse(readFileSync5(path, "utf-8"));
+}
+function readSessionByAgent(agentId) {
+  const mappingPath = join7(AGENTS_DIR, `${agentId}.json`);
+  if (!existsSync7(mappingPath)) return void 0;
+  const mapping = JSON.parse(readFileSync5(mappingPath, "utf-8"));
+  return readSession(mapping.session_id);
+}
+
+// src/cli/identity.ts
+function resolveIdentity(explicitAgentId) {
+  if (explicitAgentId) {
+    const session = readSessionByAgent(explicitAgentId);
+    if (!session) {
+      console.error(`Error: Agent "${explicitAgentId}" not found in session store.`);
+      console.error('Run "open-party setup" to register, or use --agent-id with a known ID.');
+      process.exit(1);
     }
-    return;
+    return {
+      agent_id: explicitAgentId,
+      display_name: session.display_name || explicitAgentId,
+      server_url: session.server_url || "http://127.0.0.1:8000"
+    };
   }
-  const platform = process.platform;
-  const info = getInstallInstructions(platform);
-  console.log(bold(cyan("Installing Tailscale...\n")));
-  console.log(`  Platform: ${info.os}`);
-  const result = await installTailscale(platform);
-  if (result.success) {
-    console.log(green("\n\u2705 Tailscale installed successfully!"));
-    console.log("  Run: open-party login");
-  } else {
-    console.log(red("\n\u274C Installation failed:"), result.output);
-    console.log("  Install manually: https://tailscale.com/download");
+  const envId = process.env.OPEN_PARTY_AGENT_ID;
+  if (envId) {
+    const session = readSessionByAgent(envId);
+    if (!session) {
+      console.error(`Error: Agent "${envId}" (from OPEN_PARTY_AGENT_ID) not found in session store.`);
+      process.exit(1);
+    }
+    return {
+      agent_id: envId,
+      display_name: session.display_name || envId,
+      server_url: session.server_url || "http://127.0.0.1:8000"
+    };
+  }
+  if (!existsSync8(SESSIONS_DIR)) {
+    console.error("Error: No Open Party session found.");
+    console.error('Run "open-party setup" to get started, or provide --agent-id.');
+    process.exit(1);
   }
+  const files = readdirSync4(SESSIONS_DIR).filter((f) => f.endsWith(".json"));
+  if (files.length === 0) {
+    console.error("Error: No active Open Party sessions.");
+    console.error('Run "open-party setup" to register, or provide --agent-id.');
+    process.exit(1);
+  }
+  const sorted = files.sort(
+    (a, b) => statSync3(join8(SESSIONS_DIR, b)).mtimeMs - statSync3(join8(SESSIONS_DIR, a)).mtimeMs
+  );
+  const latestFile = sorted[0];
+  const raw2 = JSON.parse(readFileSync6(join8(SESSIONS_DIR, latestFile), "utf-8"));
+  return {
+    agent_id: raw2.agent_id,
+    display_name: raw2.display_name || raw2.agent_id,
+    server_url: raw2.server_url || "http://127.0.0.1:8000"
+  };
 }
 
-// src/cli/index.ts
-function showHelp() {
-  console.log(`Usage: open-party <command> [options]
+// src/cli/send-message.ts
+async function sendMessageCommand(args2) {
+  const jsonMode = args2.includes("--json");
+  const recipient = extractFlagValue(args2, "--recipient");
+  const content = extractFlagValue(args2, "--content");
+  const summary = extractFlagValue(args2, "--summary");
+  const agentId = extractFlagValue(args2, "--agent-id");
+  if (!recipient || !content) {
+    console.error("Usage: open-party send-message --recipient <agent-id> --content <message> [--summary <text>] [--agent-id <id>] [--json]");
+    process.exit(1);
+  }
+  const identity = resolveIdentity(agentId ?? null);
+  const client = new PartyHttpClient(identity.server_url);
+  try {
+    const result = await client.sendMessage(identity.agent_id, recipient, content, summary);
+    if (jsonMode) {
+      console.log(JSON.stringify(result, null, 2));
+      return;
+    }
+    const status = result.status;
+    if (status === "delivered_locally" || status === "forwarded") {
+      console.log(`[Sent] to ${recipient}`);
+    } else if (status === "agent_not_found") {
+      console.error(`[Warning] ${recipient} not found. Use \`open-party list-agents\` to see who's online.`);
+      process.exit(1);
+    } else {
+      console.log(`[${status}] to ${recipient}`);
+    }
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    console.error(`Error: ${msg}`);
+    process.exit(1);
+  }
+}
+
+// src/cli/check-messages.ts
+async function checkMessagesCommand(args2) {
+  const jsonMode = args2.includes("--json");
+  const showHistory = args2.includes("--history");
+  const agentIdFlag = extractFlagValue(args2, "--agent-id");
+  const limitStr = extractFlagValue(args2, "--limit");
+  const limit = limitStr ? Math.min(Math.max(parseInt(limitStr, 10), 1), 50) : 10;
+  const identity = resolveIdentity(agentIdFlag);
+  const client = new PartyHttpClient(identity.server_url);
+  try {
+    const messages = await client.checkMessages(identity.agent_id);
+    if (jsonMode) {
+      const result = { messages, count: messages.length };
+      if (showHistory) {
+        const history = await client.getMessageHistory(identity.agent_id, limit);
+        result.history = history;
+        result.history_count = history.length;
+      }
+      console.log(JSON.stringify(result, null, 2));
+      return;
+    }
+    if (messages.length > 0) {
+      console.log(`New Messages (${messages.length})`);
+      for (const msg of messages) {
+        console.log("");
+        console.log("---");
+        console.log(`From: \`${msg.sender_id}\``);
+        if (msg.summary) console.log(`Summary: ${msg.summary}`);
+        console.log("");
+        console.log(`> ${msg.content}`);
+      }
+      console.log("");
+      console.log('Reply with `open-party send-message --recipient <id> --content "reply"` if needed.');
+    } else {
+      console.log("No new messages.");
+    }
+    if (showHistory) {
+      const history = await client.getMessageHistory(identity.agent_id, limit);
+      if (history.length === 0) {
+        console.log("\nNo message history yet.");
+        return;
+      }
+      console.log(`
+Message History (last ${history.length})`);
+      for (const entry of history) {
+        console.log("");
+        console.log("---");
+        const isSent = entry.sender_id === identity.agent_id;
+        const arrow = isSent ? "->" : "<-";
+        const peer = isSent ? entry.recipient_id : entry.sender_id;
+        console.log(`${arrow} To: \`${peer}\``);
+        console.log(`> ${entry.content}`);
+      }
+    }
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    console.error(`Error: ${msg}`);
+    process.exit(1);
+  }
+}
 
-Commands:
-  start     Start the Party Server (default when no command given)
-  stop      Stop the Party Server
-  status    Show server status
-  setup     Interactive setup wizard (Tailscale + agent plugins)
-  login     Login to Tailscale network
-  logout    Log out of Tailscale network
-  install   Install Tailscale
-  agents    List connected agents
-  peers     List discovered peer nodes
-  help      Show this help message
+// src/cli/online.ts
+function parseArgs(args2) {
+  const result = {};
+  for (let i = 0; i < args2.length; i++) {
+    if (args2[i] === "--name" && args2[i + 1]) {
+      result.name = args2[++i];
+    }
+  }
+  return result;
+}
+async function onlineCommand(args2 = []) {
+  const { name } = parseArgs(args2);
+  const identity = resolveIdentity();
+  const displayName = name || identity.display_name;
+  const client = new PartyHttpClient(identity.server_url);
+  try {
+    await client.health();
+  } catch {
+    console.log(`${red("Party Server is not running.")}`);
+    console.log("  Use 'open-party start' to start it.");
+    process.exit(1);
+  }
+  try {
+    await client.register(identity.agent_id, displayName, { type: "claude-code" });
+    updateOnlineStatus(identity.agent_id, true);
+    console.log(`${green(bold("Online"))}  ${identity.agent_id}  (${displayName})`);
+    console.log(`  Use ${cyan("open-party agents")} to see who else is online.`);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    console.error(`${red("Failed to go online:")} ${msg}`);
+    process.exit(1);
+  }
+}
 
-Options for 'start':
-  -d, --daemon          Run in background (daemon mode)
-  -p, --port <port>     Override port (default: 8000, env: PARTY_PORT)
+// src/cli/offline.ts
+async function offlineCommand() {
+  const identity = resolveIdentity();
+  const client = new PartyHttpClient(identity.server_url);
+  try {
+    await client.health();
+  } catch {
+    updateOnlineStatus(identity.agent_id, false);
+    console.log(`${yellow("Party Server is not running.")} Marked as offline.`);
+    return;
+  }
+  try {
+    await client.remove(identity.agent_id);
+    updateOnlineStatus(identity.agent_id, false);
+    console.log(`${green(bold("Offline"))}  ${identity.agent_id}  (${identity.display_name})`);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    console.error(`${red("Failed to go offline:")} ${msg}`);
+    process.exit(1);
+  }
+}
 
-Global options:
-  -v, --version         Show version number
+// src/cli/registry.ts
+var COMMANDS = [
+  {
+    name: "setup",
+    description: "Build & install plugin into Claude Code, then start server",
+    usage: "open-party setup"
+  },
+  {
+    name: "start",
+    description: "Start the Party Server (default when no command given)",
+    usage: "open-party start [-d] [-p <port>]",
+    options: [
+      { flags: "-d, --daemon", description: "Run in background (daemon mode)" },
+      { flags: "-p, --port <port>", description: "Override port (default: 8000, env: PARTY_PORT)" }
+    ],
+    examples: [
+      "open-party start",
+      "open-party start -d",
+      "open-party start -d -p 9000"
+    ]
+  },
+  {
+    name: "stop",
+    description: "Stop the Party Server",
+    usage: "open-party stop"
+  },
+  {
+    name: "status",
+    description: "Show server status",
+    usage: "open-party status"
+  },
+  {
+    name: "login",
+    description: "Login to Tailscale network",
+    usage: "open-party login"
+  },
+  {
+    name: "logout",
+    description: "Log out of Tailscale network",
+    usage: "open-party logout"
+  },
+  {
+    name: "agents",
+    alias: "list-agents",
+    description: "List online agents (local + remote, with status)",
+    usage: "open-party agents [--json]",
+    options: [
+      { flags: "--json", description: "Output raw JSON response" }
+    ],
+    examples: [
+      "open-party agents",
+      "open-party agents --json"
+    ]
+  },
+  {
+    name: "peers",
+    description: "List discovered peer nodes",
+    usage: "open-party peers [--json]",
+    options: [
+      { flags: "--json", description: "Output raw JSON response" }
+    ]
+  },
+  {
+    name: "send-message",
+    description: "Send a message to an agent",
+    usage: "open-party send-message --recipient <id> --content <text> [options]",
+    options: [
+      { flags: "--recipient <id>", description: "Target agent ID (required)" },
+      { flags: "--content <text>", description: "Message content (required)" },
+      { flags: "--summary <text>", description: "Optional one-line summary" },
+      { flags: "--agent-id <id>", description: "Override sender identity" },
+      { flags: "--json", description: "Output raw JSON response" }
+    ],
+    examples: [
+      'open-party send-message --recipient <id> --content "hello"',
+      'open-party send-message --recipient <id> --content "hi" --summary "Greeting"'
+    ]
+  },
+  {
+    name: "online",
+    description: "Go online \u2014 register this agent with the Party Server",
+    usage: "open-party online [--name <name>]",
+    options: [
+      { flags: "--name <name>", description: "Override display name" }
+    ],
+    examples: [
+      "open-party online",
+      'open-party online --name "my-agent"'
+    ]
+  },
+  {
+    name: "offline",
+    description: "Go offline \u2014 unregister from the Party Server",
+    usage: "open-party offline"
+  },
+  {
+    name: "check-messages",
+    description: "Check for new messages (add --history to include history)",
+    usage: "open-party check-messages [--agent-id <id>] [--history] [--limit N] [--json]",
+    options: [
+      { flags: "--agent-id <id>", description: "Override agent identity" },
+      { flags: "--history", description: "Also show message history" },
+      { flags: "--limit N", description: "Number of history messages (default: 10, max: 50)" },
+      { flags: "--json", description: "Output raw JSON response" }
+    ],
+    examples: [
+      "open-party check-messages",
+      "open-party check-messages --history",
+      "open-party check-messages --history --limit 20"
+    ]
+  }
+];
+function findCommand(name) {
+  return COMMANDS.find(
+    (c) => c.name === name || c.alias === name
+  );
+}
 
-Examples:
-  open-party                    Start server in foreground
-  open-party start              Start server in foreground
-  open-party start -d           Start server in background
-  open-party start -d -p 9000   Start server in background on port 9000
-  open-party stop               Stop the server
-  open-party status             Check if the server is running
-  open-party login              Login to Tailscale
-  open-party logout             Log out of Tailscale
-  open-party install            Install Tailscale
-  open-party agents             List connected agents
-  open-party peers              List discovered peer nodes`);
+// src/cli/index.ts
+function showHelp(commandName) {
+  if (commandName) {
+    const cmd = findCommand(commandName);
+    if (!cmd) {
+      console.log(`Unknown command: ${commandName}
+`);
+      showHelp();
+      return;
+    }
+    console.log(`Usage: ${cmd.usage}`);
+    console.log("");
+    console.log(cmd.description);
+    if (cmd.alias) {
+      console.log(`Alias: ${cmd.alias}`);
+    }
+    if (cmd.options && cmd.options.length > 0) {
+      console.log("");
+      console.log("Options:");
+      for (const opt of cmd.options) {
+        console.log(`  ${opt.flags.padEnd(24)} ${opt.description}`);
+      }
+    }
+    if (cmd.examples && cmd.examples.length > 0) {
+      console.log("");
+      console.log("Examples:");
+      for (const ex of cmd.examples) {
+        console.log(`  ${ex}`);
+      }
+    }
+    return;
+  }
+  const lines = ["Usage: open-party <command> [options]", "", "Commands:"];
+  for (const cmd of COMMANDS) {
+    const label = cmd.alias ? `${cmd.name}, ${cmd.alias}` : cmd.name;
+    lines.push(`  ${label.padEnd(22)} ${cmd.description}`);
+  }
+  lines.push("");
+  lines.push("Global options:");
+  lines.push("  -v, --version             Show version number");
+  lines.push("");
+  lines.push('Run "open-party help <command>" for details on a specific command.');
+  console.log(lines.join("\n"));
 }
 var args = process.argv.slice(2);
 var command = args[0] ?? "start";
@@ -7087,6 +5954,10 @@ async function main2() {
     showVersion();
     process.exit(0);
   }
+  if (commandArgs.includes("--help") || commandArgs.includes("-h")) {
+    showHelp(command);
+    process.exit(0);
+  }
   switch (command) {
     case "setup":
       await setupCommand();
@@ -7097,9 +5968,6 @@ async function main2() {
     case "logout":
       await logoutCommand();
       break;
-    case "install":
-      await installCommand();
-      break;
     case "start":
       await startServer(commandArgs);
       break;
@@ -7110,15 +5978,28 @@ async function main2() {
       await statusCommand();
       break;
     case "agents":
-      await agentsCommand();
+    case "list-agents":
+      await listAgentsCommand(commandArgs);
       break;
     case "peers":
-      await peersCommand();
+      await peersCommand(commandArgs);
+      break;
+    case "send-message":
+      await sendMessageCommand(commandArgs);
+      break;
+    case "check-messages":
+      await checkMessagesCommand(commandArgs);
+      break;
+    case "online":
+      await onlineCommand(commandArgs);
+      break;
+    case "offline":
+      await offlineCommand();
       break;
     case "help":
     case "--help":
     case "-h":
-      showHelp();
+      showHelp(args[1]);
       break;
     default:
       console.log(`Unknown command: ${command}