@feynmanzhang/open-party 0.1.6 → 0.1.8

package/dist/claude-code/{open-party-0.1.6 → open-party-0.1.8}/dist/party-server.js

@@ -11,11 +11,12 @@ var __export = (target, all) => {
 };
 
 // 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");
@@ -57,10 +58,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 join(LOG_DIR, `${yy}-${mm}-${dd}-open-party.log`);
+  return join(LOG_DIR, `${yyyy}-${mm}-${dd}-open-party.log`);
 }
 function shouldLog(level) {
   return LEVEL_ORDER[level] >= LEVEL_ORDER[effectiveLevel];
@@ -76,13 +77,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) {
@@ -113,7 +114,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)}` : "";
@@ -135,26 +137,6 @@ function dataDirPath() {
   if (pluginData) return join2(pluginData, "data");
   return join2(homedir2(), ".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;
-}
 function abortableSleep(ms, signal) {
   return new Promise((resolve, reject) => {
     const timer = setTimeout(resolve, ms);
@@ -168,24 +150,19 @@ 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 = join2(this._dir, SNAPSHOT_FILE);
@@ -203,13 +180,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";
@@ -232,7 +209,15 @@ var init_persistence = __esm({
         }
         try {
           const raw2 = JSON.parse(readFileSync(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;
@@ -259,22 +244,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;
       }
@@ -308,13 +285,13 @@ var init_persistence = __esm({
         return existsSync2(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);
@@ -324,36 +301,12 @@ 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);
           }
         }
       }
-      /**
-       * Schedule a debounced snapshot write.
-       * Multiple calls within DEBOUNCE_MS window are coalesced into one write.
-       */
-      scheduleSnapshot(getAgents, getHistory) {
-        if (this._debounceTimer !== null) {
-          clearTimeout(this._debounceTimer);
-        }
-        this._debounceTimer = setTimeout(() => {
-          this._debounceTimer = null;
-          try {
-            this.writeSnapshot(getAgents(), getHistory());
-          } catch (error) {
-            logger.warn("Persistence", "Debounced snapshot failed", error);
-          }
-        }, DEBOUNCE_MS);
-      }
-      /** Cancel pending debounced snapshot (called during shutdown). */
-      cancelDebounce() {
-        if (this._debounceTimer !== null) {
-          clearTimeout(this._debounceTimer);
-          this._debounceTimer = null;
-        }
-      }
     };
   }
 });
@@ -468,243 +421,293 @@ function getTailscaleIps() {
   }
   return [];
 }
-function execWithSudoFallback(cmd, timeout = 15e3) {
-  try {
-    return runExec(cmd, timeout);
-  } catch (exc) {
-    const err = exc;
-    const stderrLower = (err.stderr ?? "").toLowerCase();
-    if (PERMISSION_KEYWORDS.some((kw) => stderrLower.includes(kw))) {
-      try {
-        return runExec(["sudo", "-n", ...cmd], timeout);
-      } catch {
-      }
-    }
-    throw exc;
-  }
-}
-function joinTailnet(authKey, timeout = 3e4) {
-  const binary = getTailscaleBinary();
-  try {
-    const output2 = execWithSudoFallback(
-      [binary, "up", "--authkey", authKey],
-      timeout
-    );
-    return { success: true, output: output2.trim() };
-  } catch (e) {
-    const err = e;
-    return { success: false, output: (err.stderr ?? err.message ?? "").trim() };
-  }
-}
-function getTailscaleInstallationStatus() {
-  const binary = findTailscaleBinary();
-  if (!binary) {
-    return { state: "not_installed", platform: process.platform };
-  }
-  try {
-    const status = readTailscaleStatus();
-    const self = status.Self ?? {};
-    const online = self.Online === true;
-    if (online) {
-      const ips = self.TailscaleIPs;
-      const dns = self.DNSName?.replace(/\.$/, "");
-      return {
-        state: "connected",
-        binary,
-        tailscale_ip: ips?.[0] ?? "127.0.0.1",
-        hostname: dns ?? null
-      };
-    }
-    return { state: "not_connected", binary };
-  } catch (error) {
-    console.error("[Tailscale] Failed to get installation status:", error);
-    return {
-      state: "not_connected",
-      binary,
-      error: error instanceof Error ? error.message : String(error)
-    };
-  }
-}
-function resetTailscaleBinaryCache() {
-  cachedBinary = null;
-}
-function logoutTailscale(timeout = 15e3) {
-  const binary = getTailscaleBinary();
-  try {
-    const output2 = runExec([binary, "logout"], timeout);
-    resetTailscaleBinaryCache();
-    return { success: true, output: output2.trim() };
-  } catch (e) {
-    const err = e;
-    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((resolve) => {
-    let stdout = "";
-    let resolved = false;
-    const done = (result) => {
-      if (resolved) return;
-      resolved = true;
-      resolve(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 cachedBinary;
 var init_tailscale = __esm({
   "src/infra/tailscale.ts"() {
     "use strict";
     cachedBinary = null;
-    PERMISSION_KEYWORDS = [
-      "permission denied",
-      "access denied",
-      "operation not permitted",
-      "not permitted",
-      "requires root",
-      "must be run as root",
-      "must be run with sudo",
-      "requires sudo",
-      "need sudo"
-    ];
+  }
+});
+
+// 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;
+      }
+      /**
+       * 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.
+       */
+      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++;
+        }
+        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);
+          }
+        }
+        result.sort((a, b) => a.seq - b.seq);
+        return result;
+      }
+      /**
+       * 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;
       }
-      /** Pop up to maxCount messages for agentId. */
+      /** 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 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);
+        }
+      }
     };
   }
 });
@@ -719,7 +722,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";
@@ -728,17 +731,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();
@@ -753,10 +750,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() {
@@ -766,7 +763,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,
@@ -802,23 +799,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();
       }
       // ------------------------------------------------------------------
@@ -856,12 +849,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) {
@@ -882,55 +873,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);
+      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 === 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);
-          }
-        } 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;
@@ -973,14 +933,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);
           }
         }
@@ -1003,8 +963,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;
@@ -1017,19 +979,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) {
@@ -1038,19 +1004,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;
       }
     };
   }
@@ -1068,7 +1045,6 @@ __export(state_exports, {
   messageQueue: () => messageQueue,
   refreshSelfIp: () => refreshSelfIp,
   registry: () => registry,
-  scheduleSnapshot: () => scheduleSnapshot,
   snapshotManager: () => snapshotManager
 });
 function resolveSelfIp() {
@@ -1089,12 +1065,6 @@ function refreshSelfIp() {
   _selfIp = resolveSelfIp();
   return _selfIp;
 }
-function scheduleSnapshot() {
-  snapshotManager?.scheduleSnapshot(
-    () => registry.listAll(),
-    () => messageQueue.getHistorySnapshot()
-  );
-}
 function initSnapshotManager(mgr) {
   snapshotManager = mgr;
 }
@@ -1119,58 +1089,6 @@ var init_state = __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 args = entry.needsSudo ? [entry.cmd, ...entry.args] : entry.args;
-  console.log(`Running: ${cmd} ${args.join(" ")}
-`);
-  return new Promise((resolve) => {
-    const child = spawn(cmd, args, {
-      stdio: "inherit",
-      windowsHide: true
-    });
-    let exited = false;
-    child.on("close", (code) => {
-      if (exited) return;
-      exited = true;
-      if (code === 0) {
-        resolve({ success: true, output: "Installation completed." });
-      } else {
-        resolve({ success: false, output: `Installation exited with code ${code}` });
-      }
-    });
-    child.on("error", (err) => {
-      if (exited) return;
-      exited = true;
-      resolve({ 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 = (middleware, onError, onNotFound) => {
   return (context, next) => {
@@ -3991,12 +3909,34 @@ function sanitizeAgentList(agents) {
 // src/server/routes/agent.ts
 init_config();
 init_logger();
+
+// src/server/callback.ts
+init_logger();
+var CALLBACK_TIMEOUT_MS = 5e3;
+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}`);
+  });
+}
+
+// src/server/routes/agent.ts
 var agentRoutes = new Hono2();
 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",
@@ -4009,26 +3949,46 @@ async function forwardToPeer(peerIp, envelope) {
   }
 }
 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) => {
@@ -4039,18 +3999,31 @@ agentRoutes.get("/list", async (c) => {
   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 });
   }
@@ -4060,7 +4033,6 @@ agentRoutes.post("/send", async (c) => {
       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);
@@ -4114,9 +4086,22 @@ proxyRoutes.post("/receive", async (c) => {
   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);
@@ -4148,1224 +4133,6 @@ proxyRoutes.post("/send/:target_ip", async (c) => {
   }
 });
 
-// src/server/dashboard-html.ts
-var 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);
-}
-.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;
-}
-.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
-init_tailscale();
-init_state();
-init_logger();
-var 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);
-  }
-});
-var 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
 async function periodicCleanup() {
   while (!lifecycleController.signal.aborted) {
@@ -5373,6 +4140,10 @@ async function periodicCleanup() {
       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);
@@ -5403,7 +4174,6 @@ app.onError((err, c) => {
 });
 app.route("/agent", agentRoutes);
 app.route("/proxy", proxyRoutes);
-app.route("/dashboard", dashboardRoutes);
 function pidFilePath() {
   const pluginData = process.env.CLAUDE_PLUGIN_DATA || "";
   if (pluginData) return join4(pluginData, "server.pid");
@@ -5416,7 +4186,6 @@ async function performShutdown(server, pidPath) {
   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.");
@@ -5461,7 +4230,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",
@@ -5478,7 +4247,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);