synapse-causal-memory 0.2.2 → 0.2.3

package/dist/cli.js

@@ -1,3 +1,4 @@
+#!/usr/bin/env bun
 // @bun
 var __esm = (fn, res, err) => () => {
   if (fn)
@@ -23,6 +24,8 @@ var init_causal_config = __esm(() => {
     LOCAL_DB_PATH: resolve(import.meta.dir, "causal-memory.json"),
     DEFAULT_HOST: process.env.SYNAPSE_MEMORY_HOST || "127.0.0.1",
     DEFAULT_PORT: parseInt(process.env.SYNAPSE_MEMORY_PORT || "4242", 10),
+    REMOTE_URL: process.env.SYNAPSE_MEMORY_REMOTE_URL || "",
+    REMOTE_TIMEOUT_MS: parseInt(process.env.SYNAPSE_MEMORY_REMOTE_TIMEOUT || "3000", 10),
     MCP_PROTOCOL_VERSION: process.env.SYNAPSE_MCP_VERSION || "2024-11-05",
     MCP_SERVER_NAME: "synapse-causal-memory",
     MAX_CONTEXT_PREVIEW_LINES: parseInt(process.env.SYNAPSE_MEMORY_MAX_PREVIEW || "5", 10)
@@ -181,6 +184,42 @@ class CausalMemoryStore {
       }
     }
   }
+  static getRuleDomainPriority(rule) {
+    const titleLower = rule.title.toLowerCase();
+    const dom = rule.domain;
+    if (titleLower.includes("biophys") && dom === "User_Preferences_And_Rules") {
+      return 0;
+    }
+    if (dom === "Knowledge_Base") {
+      return 1;
+    }
+    return 2;
+  }
+  static deduplicateRulesByTitle(rules) {
+    const byTitle = new Map;
+    for (const rule of rules) {
+      if (!rule.title)
+        continue;
+      const key = rule.title.toLowerCase();
+      const existing = byTitle.get(key);
+      if (!existing) {
+        byTitle.set(key, rule);
+      } else {
+        const existingPrio = CausalMemoryStore.getRuleDomainPriority(existing);
+        const incomingPrio = CausalMemoryStore.getRuleDomainPriority(rule);
+        if (incomingPrio > existingPrio) {
+          byTitle.set(key, rule);
+        } else if (incomingPrio === existingPrio) {
+          const existingDate = existing.lastVerified || "";
+          const incomingDate = rule.lastVerified || "";
+          if (incomingDate >= existingDate) {
+            byTitle.set(key, rule);
+          }
+        }
+      }
+    }
+    return Array.from(byTitle.values());
+  }
   loadDatabase() {
     try {
       if (existsSync(this.dbPath)) {
@@ -188,7 +227,8 @@ class CausalMemoryStore {
         this.lastMtimeMs = stat.mtimeMs;
         const raw = readFileSync(this.dbPath, "utf-8");
         const parsed = JSON.parse(raw);
-        const rules = Array.isArray(parsed.rules) ? parsed.rules : [];
+        const rawRules = Array.isArray(parsed.rules) ? parsed.rules : [];
+        const rules = CausalMemoryStore.deduplicateRulesByTitle(rawRules);
         const relations = Array.isArray(parsed.relations) ? parsed.relations : [];
         return {
           version: parsed.version || CAUSAL_MEMORY_CONFIG.SCHEMA_VERSION,
@@ -637,6 +677,34 @@ class CausalMemoryStore {
     }
     return created;
   }
+  deleteRule(ruleId, persistToDisk = true) {
+    const targetId = ruleId.toLowerCase();
+    const removedTitles = new Set;
+    const filteredRules = this.database.rules.filter((r) => {
+      if (r.id.toLowerCase() === targetId) {
+        removedTitles.add(r.title.toLowerCase());
+        return false;
+      }
+      return true;
+    });
+    if (removedTitles.size === 0) {
+      return false;
+    }
+    const filteredRelations = this.database.relations.filter((rel) => !removedTitles.has(rel.from.toLowerCase()) && !removedTitles.has(rel.to.toLowerCase()) && rel.from.toLowerCase() !== targetId && rel.to.toLowerCase() !== targetId);
+    this.database = {
+      ...this.database,
+      updatedAt: new Date().toISOString(),
+      totalRules: filteredRules.length,
+      totalRelations: filteredRelations.length,
+      rules: filteredRules,
+      relations: filteredRelations
+    };
+    this.rebuildIndices();
+    if (persistToDisk) {
+      this.saveDatabase();
+    }
+    return true;
+  }
   deleteEntities(entityNames, persistToDisk = true) {
     const nameSet = new Set(entityNames.map((n) => n.toLowerCase()));
     const filteredRules = this.database.rules.filter((r) => !nameSet.has(r.title.toLowerCase()) && !nameSet.has(r.id.toLowerCase()));
@@ -701,7 +769,7 @@ class CausalMemoryStore {
     const invariants = [];
     const actions = [];
     const context = [];
-    const isTrueUserPreference = typeLower === "preference" || typeLower === "user_constraint" || typeLower === "forbidden_rules" || nameLower === "userpreferences" || nameLower === "user_web_navigation_preference" || nameLower === "python_strictly_forbidden" || nameLower === "forbidden_topics_until_mentioned";
+    const isTrueUserPreference = !nameLower.includes("biophys") && (typeLower === "preference" || typeLower === "user_constraint" || typeLower === "forbidden_rules" || nameLower === "userpreferences" || nameLower === "user_web_navigation_preference" || nameLower === "python_strictly_forbidden" || nameLower === "forbidden_topics_until_mentioned");
     if (isTrueUserPreference) {
       domain = "User_Preferences_And_Rules";
       triggers.alwaysActive = true;
@@ -763,6 +831,7 @@ class CausalMemoryStore {
   audit() {
     const issues = [];
     const seenIds = new Set;
+    const seenTitles = new Set;
     let alwaysActiveCount = 0;
     for (const rule of this.database.rules) {
       if (rule.triggers.alwaysActive) {
@@ -775,6 +844,14 @@ class CausalMemoryStore {
       } else {
         seenIds.add(rule.id);
       }
+      const titleLower = (rule.title || "").toLowerCase();
+      if (titleLower) {
+        if (seenTitles.has(titleLower)) {
+          issues.push(`\uC911\uBCF5 \uC81C\uBAA9(Title) \uBC1C\uACAC: ${rule.title}`);
+        } else {
+          seenTitles.add(titleLower);
+        }
+      }
       if (!rule.domain) {
         issues.push(`\uB3C4\uBA54\uC778 \uB204\uB77D \uADDC\uCE59: ${rule.id}`);
       }
@@ -790,6 +867,76 @@ class CausalMemoryStore {
       issues
     };
   }
+  getRawDatabase() {
+    this.reloadIfNeeded();
+    return this.database;
+  }
+  mergeDatabase(incomingRules, incomingRelations = []) {
+    this.reloadIfNeeded();
+    let addedRules = 0;
+    let updatedRules = 0;
+    let addedRelations = 0;
+    const byTitle = new Map;
+    for (const r of this.database.rules) {
+      byTitle.set(r.title.toLowerCase(), r);
+    }
+    for (const incoming of incomingRules) {
+      if (!incoming.id || !incoming.title)
+        continue;
+      const titleKey = incoming.title.toLowerCase();
+      const existing = byTitle.get(titleKey);
+      if (!existing) {
+        byTitle.set(titleKey, incoming);
+        addedRules++;
+      } else {
+        const existingPrio = CausalMemoryStore.getRuleDomainPriority(existing);
+        const incomingPrio = CausalMemoryStore.getRuleDomainPriority(incoming);
+        const existingDate = existing.lastVerified || "";
+        const incomingDate = incoming.lastVerified || "";
+        if (incomingPrio > existingPrio) {
+          byTitle.set(titleKey, incoming);
+          updatedRules++;
+        } else if (incomingPrio === existingPrio && incoming.id !== existing.id && incomingDate > existingDate) {
+          byTitle.set(titleKey, incoming);
+          updatedRules++;
+        } else if (incomingPrio === existingPrio && incoming.id === existing.id && incomingDate > existingDate) {
+          byTitle.set(titleKey, incoming);
+          updatedRules++;
+        }
+      }
+    }
+    const relationKey = (rel) => `${rel.from.toLowerCase()}::${rel.relationType.toLowerCase()}::${rel.to.toLowerCase()}`;
+    const relMap = new Map;
+    for (const rel of this.database.relations) {
+      relMap.set(relationKey(rel), rel);
+    }
+    for (const incomingRel of incomingRelations) {
+      const key = relationKey(incomingRel);
+      if (!relMap.has(key)) {
+        relMap.set(key, incomingRel);
+        addedRelations++;
+      }
+    }
+    const mergedRules = Array.from(byTitle.values());
+    const mergedRelations = Array.from(relMap.values());
+    this.database = {
+      ...this.database,
+      updatedAt: new Date().toISOString(),
+      totalRules: mergedRules.length,
+      totalRelations: mergedRelations.length,
+      rules: mergedRules,
+      relations: mergedRelations
+    };
+    this.rebuildIndices();
+    this.saveDatabase();
+    return {
+      addedRules,
+      updatedRules,
+      addedRelations,
+      totalRules: mergedRules.length,
+      totalRelations: mergedRelations.length
+    };
+  }
 }
 var init_causal_store = __esm(() => {
   init_causal_config();
@@ -1129,6 +1276,17 @@ function startCausalServer(options = {}) {
           const auditResult = store.audit();
           return new Response(JSON.stringify(auditResult), { headers });
         }
+        if (url.pathname === "/sync" && req.method === "GET") {
+          const rawDb = store.getRawDatabase();
+          return new Response(JSON.stringify(rawDb), { headers });
+        }
+        if (url.pathname === "/sync" && req.method === "POST") {
+          const body = await req.json();
+          const incomingRules = Array.isArray(body.rules) ? body.rules : [];
+          const incomingRelations = Array.isArray(body.relations) ? body.relations : [];
+          const mergeResult = store.mergeDatabase(incomingRules, incomingRelations);
+          return new Response(JSON.stringify({ ok: true, ...mergeResult }), { headers });
+        }
         if (url.pathname === "/mcp" && req.method === "POST") {
           const rpc = await req.json();
           const responseObj = await handleMcpJsonRpcRequest(rpc, store, options.dbPath);
@@ -1145,9 +1303,12 @@ function startCausalServer(options = {}) {
   });
   return server;
 }
-async function startCausalMcpStdioServer(dbPath) {
+async function startCausalMcpStdioServer(dbPath, remoteUrl) {
   const store = new CausalMemoryStore(dbPath);
-  const daemonUrl = `http://${CAUSAL_MEMORY_CONFIG.DEFAULT_HOST}:${CAUSAL_MEMORY_CONFIG.DEFAULT_PORT}/mcp`;
+  const targetRemote = remoteUrl || CAUSAL_MEMORY_CONFIG.REMOTE_URL;
+  const isRemoteMode = Boolean(targetRemote && targetRemote.trim().length > 0);
+  const activeDaemonUrl = isRemoteMode ? targetRemote.endsWith("/mcp") ? targetRemote : `${targetRemote.replace(/\/+$/, "")}/mcp` : `http://${CAUSAL_MEMORY_CONFIG.DEFAULT_HOST}:${CAUSAL_MEMORY_CONFIG.DEFAULT_PORT}/mcp`;
+  const timeoutMs = isRemoteMode ? CAUSAL_MEMORY_CONFIG.REMOTE_TIMEOUT_MS : 150;
   const rl = createInterface({
     input: process.stdin,
     terminal: false
@@ -1161,11 +1322,11 @@ async function startCausalMcpStdioServer(dbPath) {
       let responseObj = null;
       if (rpc.method === "tools/call") {
         try {
-          const daemonRes = await fetch(daemonUrl, {
+          const daemonRes = await fetch(activeDaemonUrl, {
             method: "POST",
             headers: { "Content-Type": "application/json" },
             body: trimmed,
-            signal: AbortSignal.timeout(150)
+            signal: AbortSignal.timeout(timeoutMs)
           });
           if (daemonRes.ok) {
             responseObj = await daemonRes.json();
@@ -1930,6 +2091,177 @@ function migrateLegacyMemoryGraph(sourceBackupPath = CAUSAL_MEMORY_CONFIG.LEGACY
   };
 }
 
+// causal-peer.ts
+init_causal_config();
+init_causal_store();
+async function getTailscalePeers() {
+  try {
+    const proc = Bun.spawn(["tailscale", "status", "--json"], {
+      stdout: "pipe",
+      stderr: "pipe"
+    });
+    const output = await new Response(proc.stdout).text();
+    const data = JSON.parse(output);
+    const selfIp = data.Self?.TailscaleIPs?.[0];
+    const selfHost = data.Self?.HostName;
+    const peers = [];
+    if (data.Self) {
+      peers.push({
+        id: data.Self.ID || "self",
+        hostName: data.Self.HostName || "localhost",
+        ip: selfIp || "127.0.0.1",
+        os: data.Self.OS || process.platform,
+        online: data.Self.Online ?? true,
+        active: true,
+        isSelf: true
+      });
+    }
+    if (data.Peer) {
+      for (const key of Object.keys(data.Peer)) {
+        const p = data.Peer[key];
+        const peerIp = p.TailscaleIPs?.[0] || "";
+        peers.push({
+          id: p.ID || key,
+          hostName: p.HostName || "",
+          ip: peerIp,
+          os: p.OS || "unknown",
+          online: Boolean(p.Online),
+          active: Boolean(p.Active),
+          isSelf: false
+        });
+      }
+    }
+    return { selfIp, selfHost, peers };
+  } catch (error) {
+    return {
+      peers: []
+    };
+  }
+}
+async function pingPeer(host, port = CAUSAL_MEMORY_CONFIG.DEFAULT_PORT) {
+  const url = `http://${host}:${port}/health`;
+  const startTime = performance.now();
+  try {
+    const res = await fetch(url, {
+      method: "GET",
+      signal: AbortSignal.timeout(CAUSAL_MEMORY_CONFIG.REMOTE_TIMEOUT_MS)
+    });
+    const rttMs = Math.round((performance.now() - startTime) * 100) / 100;
+    if (!res.ok) {
+      return {
+        host,
+        port,
+        url,
+        reachable: false,
+        rttMs,
+        error: `HTTP ${res.status} ${res.statusText}`
+      };
+    }
+    const data = await res.json();
+    return {
+      host,
+      port,
+      url,
+      reachable: true,
+      rttMs,
+      version: data.status?.version,
+      totalRules: data.status?.totalRules,
+      totalRelations: data.status?.totalRelations
+    };
+  } catch (error) {
+    const rttMs = Math.round((performance.now() - startTime) * 100) / 100;
+    return {
+      host,
+      port,
+      url,
+      reachable: false,
+      rttMs,
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+async function queryRemotePeer(remoteUrl, options) {
+  const cleanUrl = remoteUrl.replace(/\/+$/, "");
+  const endpoint = cleanUrl.endsWith("/query") ? cleanUrl : `${cleanUrl}/query`;
+  const res = await fetch(endpoint, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(options),
+    signal: AbortSignal.timeout(CAUSAL_MEMORY_CONFIG.REMOTE_TIMEOUT_MS)
+  });
+  if (!res.ok) {
+    throw new Error(`\uC6D0\uACA9 \uC778\uACFC\uC728 \uCFFC\uB9AC \uC2E4\uD328: HTTP ${res.status} ${res.statusText}`);
+  }
+  return await res.json();
+}
+async function syncWithPeer(remoteHost, port = CAUSAL_MEMORY_CONFIG.DEFAULT_PORT, direction = "pull", dbPath) {
+  const store = new CausalMemoryStore(dbPath);
+  const cleanHost = remoteHost.replace(/^https?:\/\//, "").split(":")[0];
+  const targetPort = remoteHost.includes(":") ? parseInt(remoteHost.split(":")[1].replace(/\/.*/, ""), 10) || port : port;
+  const baseUrl = `http://${cleanHost}:${targetPort}`;
+  const startTime = performance.now();
+  try {
+    if (direction === "pull") {
+      const res = await fetch(`${baseUrl}/sync`, {
+        method: "GET",
+        signal: AbortSignal.timeout(CAUSAL_MEMORY_CONFIG.REMOTE_TIMEOUT_MS)
+      });
+      if (!res.ok) {
+        throw new Error(`\uC6D0\uACA9 \uB370\uC774\uD130 \uAC00\uC838\uC624\uAE30 \uC2E4\uD328: HTTP ${res.status}`);
+      }
+      const remoteDb = await res.json();
+      const rules = Array.isArray(remoteDb.rules) ? remoteDb.rules : [];
+      const relations = Array.isArray(remoteDb.relations) ? remoteDb.relations : [];
+      const mergeResult = store.mergeDatabase(rules, relations);
+      const durationMs = Math.round((performance.now() - startTime) * 100) / 100;
+      return {
+        targetHost: cleanHost,
+        direction: "pull",
+        success: true,
+        durationMs,
+        addedRules: mergeResult.addedRules,
+        updatedRules: mergeResult.updatedRules,
+        addedRelations: mergeResult.addedRelations,
+        totalRules: mergeResult.totalRules,
+        totalRelations: mergeResult.totalRelations
+      };
+    } else {
+      const rawDb = store.getRawDatabase();
+      const res = await fetch(`${baseUrl}/sync`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(rawDb),
+        signal: AbortSignal.timeout(CAUSAL_MEMORY_CONFIG.REMOTE_TIMEOUT_MS)
+      });
+      if (!res.ok) {
+        throw new Error(`\uC6D0\uACA9 \uB370\uC774\uD130 \uD478\uC2DC \uC2E4\uD328: HTTP ${res.status}`);
+      }
+      const pushResult = await res.json();
+      const durationMs = Math.round((performance.now() - startTime) * 100) / 100;
+      return {
+        targetHost: cleanHost,
+        direction: "push",
+        success: true,
+        durationMs,
+        addedRules: pushResult.addedRules,
+        updatedRules: pushResult.updatedRules,
+        addedRelations: pushResult.addedRelations,
+        totalRules: pushResult.totalRules,
+        totalRelations: pushResult.totalRelations
+      };
+    }
+  } catch (error) {
+    const durationMs = Math.round((performance.now() - startTime) * 100) / 100;
+    return {
+      targetHost: cleanHost,
+      direction,
+      success: false,
+      durationMs,
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+
 // cli.ts
 var RESET2 = "\x1B[0m";
 var BOLD2 = "\x1B[1m";
@@ -1950,6 +2282,7 @@ ${BOLD2}\uC11C\uBE0C \uBA85\uB839\uC5B4:${RESET2}
   list        \uB4F1\uB85D\uB41C \uB3C4\uBA54\uC778, \uC778\uACFC \uADDC\uCE59 \uBC0F \uC778\uACFC \uAC04\uC120(Relations) \uD1B5\uACC4 \uD655\uC778
   audit       \uC778\uACFC\uC728 \uBA54\uBAA8\uB9AC \uB370\uC774\uD130\uBCA0\uC774\uC2A4 \uBB34\uACB0\uC131 \uBC0F \uD1A0\uD070 \uC808\uAC10 \uC0C1\uD0DC \uAC10\uC0AC
   assert      \uC2E0\uADDC \uC778\uACFC\uC728 \uADDC\uCE59 \uB4F1\uB85D \uB610\uB294 \uAC31\uC2E0 (--json '<json>')
+  peer        Tailscale \uC0AC\uC124 \uBA54\uC26C \uD53C\uC5B4 \uD0D0\uC0C9, \uD551(RTT) \uBC0F \uBA54\uBAA8\uB9AC \uC6D0\uACA9 \uB3D9\uAE30\uD654
   migrate     \uAD6C\uD615 \uC9C0\uC2DD \uADF8\uB798\uD504 \uBC31\uC5C5\uBCF8\uC744 \uC778\uACFC\uC728 \uBA54\uBAA8\uB9AC \uB370\uC774\uD130\uBCA0\uC774\uC2A4\uB85C \uBB34\uC190\uC2E4 \uBCC0\uD658
   benchmark   4\uB300 \uCC28\uC6D0 \uACFC\uBD80\uD558 \uC2A4\uD2B8\uB808\uC2A4 \uBCA4\uCE58\uB9C8\uD06C \uC2E4\uD589 (--scale 10000 --concurrency 50)
   serve       \uB3C5\uB9BD \uB85C\uCEEC \uBC31\uADF8\uB77C\uC6B4\uB4DC \uC11C\uBC84/\uB370\uBAAC \uAD6C\uB3D9 (0ms \uC778\uBA54\uBAA8\uB9AC HTTP & MCP API)
@@ -1960,11 +2293,21 @@ ${BOLD2}query \uC635\uC158:${RESET2}
   --keywords <words...>    \uD2B8\uB9AC\uAC70 \uAC80\uC0C9 \uD0A4\uC6CC\uB4DC
   --command <cmd>          \uD2B8\uB9AC\uAC70 \uC5F0\uB3D9 \uBA85\uB839\uC5B4 (\uC608: release, build, sign)
   --domain <domain>        \uD2B9\uC815 \uB3C4\uBA54\uC778\uC73C\uB85C \uAC80\uC0C9 \uC81C\uD55C
+  --remote <url>           \uC6D0\uACA9 \uB370\uBAAC\uC73C\uB85C \uACF5\uBA85 \uCFFC\uB9AC \uC694\uCCAD (\uC608: http://100.82.92.122:4242)
   --format <json|md|compact> \uCD9C\uB825 \uD3EC\uB9F7 \uC9C0\uC815
 
 ${BOLD2}serve \uC635\uC158:${RESET2}
   --port <number>          \uC11C\uBC84 \uD3EC\uD2B8 \uBC88\uD638 (\uAE30\uBCF8: ${CAUSAL_MEMORY_CONFIG.DEFAULT_PORT})
   --host <string>          \uBC14\uC778\uB529 \uD638\uC2A4\uD2B8 (\uAE30\uBCF8: ${CAUSAL_MEMORY_CONFIG.DEFAULT_HOST})
+  --tailscale              Tailscale \uC0AC\uC124 IP\uB85C \uC790\uB3D9 \uBC14\uC778\uB529 (\uBA54\uC26C \uACF5\uC720 \uBAA8\uB4DC)
+
+${BOLD2}peer \uC0AC\uC6A9\uBC95:${RESET2}
+  synapse memory peer list                  Tailscale \uBA54\uC26C \uD53C\uC5B4 \uBC0F \uB370\uBAAC \uAC00\uB3D9 \uC0C1\uD0DC \uC870\uD68C
+  synapse memory peer ping <ip>             \uB300\uC0C1 \uD53C\uC5B4\uC758 Causal Memory \uD5EC\uC2A4\uCCB4\uD06C \uBC0F RTT \uCE21\uC815
+  synapse memory peer sync <ip> [--push]    \uB300\uC0C1 \uD53C\uC5B4\uC640 \uC778\uACFC\uC728 \uC9C0\uC2DD \uB370\uC774\uD130\uBCA0\uC774\uC2A4 \uC591\uBC29\uD5A5 \uB3D9\uAE30\uD654
+
+${BOLD2}mcp-stdio \uC635\uC158:${RESET2}
+  --remote <url>           \uC6D0\uACA9 \uB370\uBAAC \uD504\uB85D\uC2DC \uBAA8\uB4DC \uAD6C\uB3D9 (\uC608: http://100.82.92.122:4242)
 
 ${BOLD2}\uACF5\uD1B5 \uD50C\uB798\uADF8:${RESET2}
   --agent, --compact       AI \uC5D0\uC774\uC804\uD2B8 \uC804\uC6A9 \uCD08\uACBD\uB7C9 JSON \uBAA8\uB4DC
@@ -1979,7 +2322,14 @@ async function handleMemoryCommand(args, options) {
     return 0;
   }
   if (subCommand === "mcp-stdio") {
-    await startCausalMcpStdioServer();
+    let remoteUrl;
+    for (let i = 0;i < subArgs.length; i++) {
+      if (subArgs[i] === "--remote" && subArgs[i + 1]) {
+        remoteUrl = subArgs[i + 1];
+        break;
+      }
+    }
+    await startCausalMcpStdioServer(undefined, remoteUrl);
     return 0;
   }
   if (subCommand === "benchmark") {
@@ -2051,6 +2401,7 @@ ${BOLD2}${GREEN2}\u2728 [Causal Memory \uB9C8\uC774\uADF8\uB808\uC774\uC158 \uC6
     const keywords = [];
     let command;
     let domain;
+    let remoteUrl;
     let format = options.compactMode ? "compact" : options.agentMode ? "json" : "text";
     for (let i = 0;i < subArgs.length; i++) {
       const arg = subArgs[i];
@@ -2072,11 +2423,13 @@ ${BOLD2}${GREEN2}\u2728 [Causal Memory \uB9C8\uC774\uADF8\uB808\uC774\uC158 \uC6
         command = subArgs[++i];
       } else if (arg === "--domain" || arg === "-d") {
         domain = subArgs[++i];
+      } else if (arg === "--remote") {
+        remoteUrl = subArgs[++i];
       } else if (arg === "--format") {
         format = subArgs[++i];
       }
     }
-    const result = await runCausalQuery({
+    const result = remoteUrl ? await queryRemotePeer(remoteUrl, { files, keywords, command, domain }) : await runCausalQuery({
       files,
       keywords,
       command,
@@ -2194,9 +2547,160 @@ ${BOLD2}${RED2}\uD83D\uDEA8 [Causal Memory Audit \uACB0\uD568 \uBC1C\uACAC] \uCD
       return 1;
     }
   }
+  if (subCommand === "peer") {
+    const peerAction = subArgs.find((a) => a !== "peer" && !a.startsWith("-")) || "list";
+    if (peerAction === "list") {
+      const { selfIp, selfHost, peers } = await getTailscalePeers();
+      if (peers.length === 0) {
+        if (options.agentMode) {
+          process.stdout.write(JSON.stringify({ ok: false, message: "No Tailscale peers detected" }) + `
+`);
+        } else {
+          process.stdout.write(`${YELLOW2}\u26A0\uFE0F Tailscale\uC774 \uC2E4\uD589 \uC911\uC774\uC9C0 \uC54A\uAC70\uB098 \uAC10\uC9C0\uB41C \uD53C\uC5B4\uAC00 \uC5C6\uC2B5\uB2C8\uB2E4.${RESET2}
+`);
+        }
+        return 1;
+      }
+      const healthPromises = peers.map(async (p) => {
+        if (!p.ip) {
+          return {
+            ...p,
+            reachable: false,
+            rttMs: -1,
+            totalRules: undefined,
+            totalRelations: undefined
+          };
+        }
+        const health = await pingPeer(p.ip);
+        return {
+          ...p,
+          reachable: health.reachable,
+          rttMs: health.rttMs,
+          totalRules: health.totalRules,
+          totalRelations: health.totalRelations
+        };
+      });
+      const checkedPeers = await Promise.all(healthPromises);
+      if (options.agentMode) {
+        process.stdout.write(JSON.stringify({ ok: true, selfIp, selfHost, peers: checkedPeers }) + `
+`);
+        return 0;
+      }
+      process.stdout.write(`
+${BOLD2}${CYAN2}\uD83C\uDF10 [Causal Memory] Tailscale \uC0AC\uC124 \uBA54\uC26C \uD53C\uC5B4 \uD1A0\uD3F4\uB85C\uC9C0${RESET2}
+`);
+      process.stdout.write(`  \u2022 \uB85C\uCEEC \uB178\uB4DC: ${BOLD2}${GREEN2}${selfHost || "localhost"}${RESET2} (${selfIp || "127.0.0.1"})
+
+`);
+      for (const p of checkedPeers) {
+        const statusBadge = p.isSelf ? `${BOLD2}${CYAN2}[LOCAL HOST]${RESET2}` : p.reachable ? `${BOLD2}${GREEN2}[DAEMON ONLINE]${RESET2}` : p.online ? `${YELLOW2}[PEER UP (NO DAEMON)]${RESET2}` : `${GRAY2}[OFFLINE]${RESET2}`;
+        const rttText = p.rttMs >= 0 ? `${p.rttMs}ms` : "-";
+        const memoryInfo = p.reachable ? `(\uADDC\uCE59 ${p.totalRules}\uAC1C, \uAC04\uC120 ${p.totalRelations}\uAC1C)` : "";
+        process.stdout.write(`  \u2022 ${BOLD2}${p.hostName.padEnd(24)}${RESET2} ${GRAY2}${p.ip.padEnd(16)}${RESET2} ${statusBadge} ${GRAY2}${rttText}${RESET2} ${memoryInfo}
+`);
+      }
+      process.stdout.write(`
+`);
+      return 0;
+    }
+    if (peerAction === "ping") {
+      const targetHost = subArgs.filter((a) => a !== "peer" && a !== "ping" && !a.startsWith("-"))[0];
+      if (!targetHost) {
+        process.stderr.write(`${RED2}\u274C \uB300\uC0C1 IP \uB610\uB294 \uD638\uC2A4\uD2B8\uBA85\uC774 \uD544\uC694\uD569\uB2C8\uB2E4. (\uC608: synapse memory peer ping 100.73.80.80)${RESET2}
+`);
+        return 1;
+      }
+      const health = await pingPeer(targetHost);
+      if (options.agentMode) {
+        process.stdout.write(JSON.stringify(health) + `
+`);
+        return health.reachable ? 0 : 1;
+      }
+      if (health.reachable) {
+        process.stdout.write(`
+${BOLD2}${GREEN2}\u2714 [Causal Memory Peer \uC751\uB2F5 \uC131\uACF5]${RESET2}
+`);
+        process.stdout.write(`  \u2022 \uD53C\uC5B4 \uC8FC\uC18C : ${CYAN2}${health.url}${RESET2}
+`);
+        process.stdout.write(`  \u2022 \uC751\uB2F5 \uC9C0\uC5F0 : ${BOLD2}${health.rttMs}ms${RESET2}
+`);
+        process.stdout.write(`  \u2022 \uC5D4\uC9C4 \uBC84\uC804 : v${health.version}
+`);
+        process.stdout.write(`  \u2022 \uBCF4\uC720 \uADDC\uCE59 : ${BOLD2}${health.totalRules}\uAC1C${RESET2} (\uAC04\uC120: ${health.totalRelations}\uAC1C)
+
+`);
+        return 0;
+      } else {
+        process.stderr.write(`
+${BOLD2}${RED2}\u2716 [Causal Memory Peer \uC751\uB2F5 \uC5C6\uC74C]${RESET2}
+`);
+        process.stderr.write(`  \u2022 \uD53C\uC5B4 \uC8FC\uC18C : ${health.url}
+`);
+        process.stderr.write(`  \u2022 \uB808\uC774\uD134\uC2DC  : ${health.rttMs}ms
+`);
+        process.stderr.write(`  \u2022 \uC5D0\uB7EC \uB0B4\uC6A9 : ${health.error || "\uC5F0\uACB0 \uAC70\uBD80 \uB610\uB294 \uD0C0\uC784\uC544\uC6C3"}
+`);
+        process.stderr.write(`  \u2022 \uC870\uCE58 \uD301   : \uC0C1\uB300\uBC29 PC\uC5D0\uC11C 'synapse memory serve --tailscale' \uB370\uBAAC\uC774 \uC2E4\uD589 \uC911\uC778\uC9C0 \uD655\uC778\uD558\uC138\uC694.
+
+`);
+        return 1;
+      }
+    }
+    if (peerAction === "sync") {
+      const targetHost = subArgs.filter((a) => a !== "peer" && a !== "sync" && !a.startsWith("-"))[0];
+      if (!targetHost) {
+        process.stderr.write(`${RED2}\u274C \uB3D9\uAE30\uD654 \uB300\uC0C1 IP\uAC00 \uD544\uC694\uD569\uB2C8\uB2E4. (\uC608: synapse memory peer sync 100.73.80.80)${RESET2}
+`);
+        return 1;
+      }
+      const isPush = subArgs.includes("--push");
+      const direction = isPush ? "push" : "pull";
+      const syncResult = await syncWithPeer(targetHost, CAUSAL_MEMORY_CONFIG.DEFAULT_PORT, direction);
+      if (options.agentMode) {
+        process.stdout.write(JSON.stringify(syncResult) + `
+`);
+        return syncResult.success ? 0 : 1;
+      }
+      if (syncResult.success) {
+        process.stdout.write(`
+${BOLD2}${GREEN2}\u2728 [Causal Memory \uB3D9\uAE30\uD654 \uC131\uACF5 (${direction.toUpperCase()})]${RESET2}
+`);
+        process.stdout.write(`  \u2022 \uB300\uC0C1 \uD53C\uC5B4 : ${CYAN2}${syncResult.targetHost}${RESET2}
+`);
+        process.stdout.write(`  \u2022 \uCD94\uAC00\uB41C \uADDC\uCE59: ${BOLD2}${syncResult.addedRules}\uAC1C${RESET2} (\uAC31\uC2E0: ${syncResult.updatedRules}\uAC1C)
+`);
+        process.stdout.write(`  \u2022 \uCD94\uAC00\uB41C \uAC04\uC120: ${BOLD2}${syncResult.addedRelations}\uAC1C${RESET2}
+`);
+        process.stdout.write(`  \u2022 \uCD1D \uC9C0\uC2DD \uC218 : \uADDC\uCE59 ${syncResult.totalRules}\uAC1C, \uAC04\uC120 ${syncResult.totalRelations}\uAC1C
+`);
+        process.stdout.write(`  \u2022 \uC18C\uC694 \uC2DC\uAC04 : ${syncResult.durationMs}ms
+
+`);
+        return 0;
+      } else {
+        process.stderr.write(`
+${BOLD2}${RED2}\uD83D\uDEA8 [Causal Memory \uB3D9\uAE30\uD654 \uC2E4\uD328]${RESET2}
+`);
+        process.stderr.write(`  \u2022 \uB300\uC0C1 \uD53C\uC5B4 : ${syncResult.targetHost}
+`);
+        process.stderr.write(`  \u2022 \uC5D0\uB7EC \uC0AC\uC720 : ${syncResult.error}
+
+`);
+        return 1;
+      }
+    }
+    process.stderr.write(`${RED2}\u274C \uC9C0\uC6D0\uD558\uC9C0 \uC54A\uB294 peer \uC11C\uBE0C \uBA85\uB839\uC5B4: '${peerAction}' (list, ping, sync)${RESET2}
+`);
+    return 1;
+  }
   if (subCommand === "serve") {
     let port = CAUSAL_MEMORY_CONFIG.DEFAULT_PORT;
     let host = CAUSAL_MEMORY_CONFIG.DEFAULT_HOST;
+    const isTailscale = subArgs.includes("--tailscale");
+    if (isTailscale) {
+      const { selfIp } = await getTailscalePeers();
+      host = selfIp || "0.0.0.0";
+    }
     for (let i = 0;i < subArgs.length; i++) {
       if (subArgs[i] === "--port" && subArgs[i + 1]) {
         port = parseInt(subArgs[i + 1], 10);
@@ -2205,14 +2709,15 @@ ${BOLD2}${RED2}\uD83D\uDEA8 [Causal Memory Audit \uACB0\uD568 \uBC1C\uACAC] \uCD
       }
     }
     const server = startCausalServer({ port, host });
-    if (options.agentMode) {
-      process.stdout.write(JSON.stringify({ ok: true, port: server.port, host, url: `http://${host}:${server.port}` }) + `
+    if (options?.agentMode) {
+      process.stdout.write(JSON.stringify({ ok: true, port: server.port, host, url: `http://${host}:${server.port}`, tailscale: isTailscale }) + `
 `);
     } else {
       process.stdout.write(`
 ${BOLD2}${GREEN2}\uD83D\uDE80 [Causal Memory Daemon \uAC00\uB3D9 \uC644\uB8CC]${RESET2}
-  \u2022 \uC8FC\uC18C: ${CYAN2}http://${host}:${server.port}${RESET2}
-  \u2022 MCP API: ${GRAY2}http://${host}:${server.port}/mcp${RESET2}
+  \u2022 \uB85C\uCEEC \uBC14\uC778\uB529: ${CYAN2}http://${host}:${server.port}${RESET2}
+  \u2022 MCP API URL: ${GRAY2}http://${host}:${server.port}/mcp${RESET2}
+  \u2022 \uBAA8\uB4DC       : ${isTailscale ? `${BOLD2}${GREEN2}Tailscale \uC0AC\uC124 \uBA54\uC26C \uBAA8\uB4DC (\uC678\uBD80 \uD53C\uC5B4 \uC811\uADFC \uD5C8\uC6A9)${RESET2}` : "\uB85C\uCEEC \uB8E8\uD504\uBC31 \uBAA8\uB4DC"}
   \u2022 0ms \uC778\uBA54\uBAA8\uB9AC \uACF5\uBA85 \uB300\uAE30 \uC911... (\uC885\uB8CC: Ctrl+C)
 
 `);
@@ -2225,6 +2730,21 @@ ${BOLD2}${GREEN2}\uD83D\uDE80 [Causal Memory Daemon \uAC00\uB3D9 \uC644\uB8CC]${
   printMemoryHelp();
   return 1;
 }
+if (import.meta.main) {
+  const rawArgs = process.argv.slice(2);
+  const options = {
+    agentMode: rawArgs.includes("--agent") || rawArgs.includes("--compact"),
+    compact: rawArgs.includes("--compact"),
+    force: rawArgs.includes("--force") || rawArgs.includes("-f")
+  };
+  handleMemoryCommand(rawArgs, options).then((code) => {
+    process.exit(code);
+  }).catch((err) => {
+    process.stderr.write(`\u274C Error: ${err instanceof Error ? err.message : String(err)}
+`);
+    process.exit(1);
+  });
+}
 export {
   handleMemoryCommand
 };