@memtensor/memos-local-openclaw-plugin 1.0.4-beta.0 → 1.0.4-beta.10

package/src/viewer/server.ts

@@ -84,6 +84,12 @@ export class ViewerServer {
     { running: false, done: false, stopped: false, processed: 0, total: 0, tasksCreated: 0, skillsCreated: 0, errors: 0, skippedSessions: 0, totalSessions: 0 };
   private ppSSEClients: http.ServerResponse[] = [];
 
+  private notifSSEClients: http.ServerResponse[] = [];
+  private notifPollTimer?: ReturnType<typeof setInterval>;
+  private lastKnownNotifCount = 0;
+  private hubHeartbeatTimer?: ReturnType<typeof setInterval>;
+  private static readonly HUB_HEARTBEAT_INTERVAL_MS = 45_000;
+
   constructor(opts: ViewerServerOptions) {
     this.store = opts.store;
     this.embedder = opts.embedder;
@@ -103,15 +109,16 @@ export class ViewerServer {
       this.server.on("error", (err: NodeJS.ErrnoException) => {
         if (err.code === "EADDRINUSE") {
           this.log.warn(`Viewer port ${this.port} in use, trying ${this.port + 1}`);
-          this.server!.listen(this.port + 1, "127.0.0.1");
+          this.server!.listen(this.port + 1, "0.0.0.0");
         } else {
           reject(err);
         }
       });
-      this.server.listen(this.port, "127.0.0.1", () => {
+      this.server.listen(this.port, "0.0.0.0", () => {
         const addr = this.server!.address();
         const actualPort = typeof addr === "object" && addr ? addr.port : this.port;
         this.autoCleanupPolluted();
+        this.startHubHeartbeat();
         resolve(`http://127.0.0.1:${actualPort}`);
       });
     });
@@ -134,6 +141,10 @@ export class ViewerServer {
   }
 
   stop(): void {
+    this.stopHubHeartbeat();
+    this.stopNotifPoll();
+    for (const c of this.notifSSEClients) { try { c.end(); } catch {} }
+    this.notifSSEClients = [];
     this.server?.close();
     this.server = null;
   }
@@ -224,6 +235,11 @@ export class ViewerServer {
       }
 
       if (p === "/api/memories" && req.method === "GET") this.serveMemories(res, url);
+      else if (p === "/api/memories/share-local" && req.method === "POST") this.handleMemoryLocalShare(req, res);
+      else if (p === "/api/memories/unshare-local" && req.method === "POST") this.handleMemoryLocalUnshare(req, res);
+      else if (p.match(/^\/api\/memory\/[^/]+\/scope$/) && req.method === "PUT") this.handleMemoryScope(req, res, p);
+      else if (p.match(/^\/api\/task\/[^/]+\/scope$/) && req.method === "PUT") this.handleTaskScope(req, res, p);
+      else if (p.match(/^\/api\/skill\/[^/]+\/scope$/) && req.method === "PUT") this.handleSkillScope(req, res, p);
       else if (p === "/api/stats") this.serveStats(res, url);
       else if (p === "/api/metrics") this.serveMetrics(res, url);
       else if (p === "/api/tool-metrics") this.serveToolMetrics(res, url);
@@ -251,6 +267,9 @@ export class ViewerServer {
       else if (p === "/api/sharing/pending-users" && req.method === "GET") this.serveSharingPendingUsers(res);
       else if (p === "/api/sharing/approve-user" && req.method === "POST") this.handleSharingApproveUser(req, res);
       else if (p === "/api/sharing/reject-user" && req.method === "POST") this.handleSharingRejectUser(req, res);
+      else if (p === "/api/sharing/remove-user" && req.method === "POST") this.handleSharingRemoveUser(req, res);
+      else if (p === "/api/sharing/change-role" && req.method === "POST") this.handleSharingChangeRole(req, res);
+      else if (p === "/api/sharing/retry-join" && req.method === "POST") this.handleRetryJoin(req, res);
       else if (p === "/api/sharing/search/memories" && req.method === "POST") this.handleSharingMemorySearch(req, res);
       else if (p === "/api/sharing/memories/list" && req.method === "GET") this.serveSharingMemoryList(res, url);
       else if (p === "/api/sharing/tasks/list" && req.method === "GET") this.serveSharingTaskList(res, url);
@@ -260,23 +279,23 @@ export class ViewerServer {
       else if (p === "/api/sharing/tasks/share" && req.method === "POST") this.handleSharingTaskShare(req, res);
       else if (p === "/api/sharing/tasks/unshare" && req.method === "POST") this.handleSharingTaskUnshare(req, res);
       else if (p === "/api/sharing/update-username" && req.method === "POST") this.handleUpdateUsername(req, res);
+      else if (p === "/api/sharing/rename-user" && req.method === "POST") this.handleAdminRenameUser(req, res);
       else if (p === "/api/sharing/test-hub" && req.method === "POST") this.handleTestHubConnection(req, res);
       else if (p === "/api/sharing/memories/share" && req.method === "POST") this.handleSharingMemoryShare(req, res);
       else if (p === "/api/sharing/memories/unshare" && req.method === "POST") this.handleSharingMemoryUnshare(req, res);
       else if (p === "/api/sharing/skills/pull" && req.method === "POST") this.handleSharingSkillPull(req, res);
       else if (p === "/api/sharing/skills/share" && req.method === "POST") this.handleSharingSkillShare(req, res);
       else if (p === "/api/sharing/skills/unshare" && req.method === "POST") this.handleSharingSkillUnshare(req, res);
-      else if (p === "/api/sharing/groups" && req.method === "GET") this.serveSharingGroups(res);
-      else if (p === "/api/sharing/groups" && req.method === "POST") this.handleSharingGroupCreate(req, res);
-      else if (p.match(/^\/api\/sharing\/groups\/[^/]+$/) && req.method === "PUT") this.handleSharingGroupUpdate(req, res, p);
-      else if (p.match(/^\/api\/sharing\/groups\/[^/]+$/) && req.method === "DELETE") this.handleSharingGroupDelete(res, p);
-      else if (p.match(/^\/api\/sharing\/groups\/[^/]+\/members$/) && req.method === "GET") this.serveSharingGroupMembers(res, p);
-      else if (p.match(/^\/api\/sharing\/groups\/[^/]+\/members$/) && req.method === "POST") this.handleSharingGroupAddMember(req, res, p);
-      else if (p.match(/^\/api\/sharing\/groups\/[^/]+\/members$/) && req.method === "DELETE") this.handleSharingGroupRemoveMember(req, res, p);
       else if (p === "/api/sharing/users" && req.method === "GET") this.serveSharingUsers(res);
+      else if (p === "/api/sharing/notifications" && req.method === "GET") this.serveSharingNotifications(res, url);
+      else if (p === "/api/sharing/notifications/read" && req.method === "POST") this.handleSharingNotificationsRead(req, res);
+      else if (p === "/api/sharing/notifications/clear" && req.method === "POST") this.handleSharingNotificationsClear(req, res);
+      else if (p === "/api/notifications/stream" && req.method === "GET") this.handleNotifSSE(req, res);
       else if (p === "/api/admin/shared-tasks" && req.method === "GET") this.serveAdminSharedTasks(res);
+      else if (p.match(/^\/api\/admin\/shared-tasks\/[^/]+\/detail$/) && req.method === "GET") this.serveHubTaskDetail(res, p);
       else if (p.match(/^\/api\/admin\/shared-tasks\/[^/]+$/) && req.method === "DELETE") this.handleAdminDeleteTask(res, p);
       else if (p === "/api/admin/shared-skills" && req.method === "GET") this.serveAdminSharedSkills(res);
+      else if (p.match(/^\/api\/admin\/shared-skills\/[^/]+\/detail$/) && req.method === "GET") this.serveHubSkillDetail(res, p);
       else if (p.match(/^\/api\/admin\/shared-skills\/[^/]+$/) && req.method === "DELETE") this.handleAdminDeleteSkill(res, p);
       else if (p === "/api/admin/shared-memories" && req.method === "GET") this.serveAdminSharedMemories(res);
       else if (p.match(/^\/api\/admin\/shared-memories\/[^/]+$/) && req.method === "DELETE") this.handleAdminDeleteMemory(res, p);
@@ -431,22 +450,30 @@ export class ViewerServer {
     const params: any[] = [];
     if (session) { conditions.push("session_key = ?"); params.push(session); }
     if (role) { conditions.push("role = ?"); params.push(role); }
-    if (owner) { conditions.push("owner = ?"); params.push(owner); }
+    if (owner && owner.startsWith("agent:")) {
+      conditions.push("(owner = ? OR owner = 'public')");
+      params.push(owner);
+    } else if (owner) {
+      conditions.push("owner = ?"); params.push(owner);
+    }
     if (dateFrom) { conditions.push("created_at >= ?"); params.push(new Date(dateFrom).getTime()); }
     if (dateTo) { conditions.push("created_at <= ?"); params.push(new Date(dateTo).getTime()); }
 
     const where = conditions.length > 0 ? " WHERE " + conditions.join(" AND ") : "";
     const totalRow = db.prepare("SELECT COUNT(*) as count FROM chunks" + where).get(...params) as any;
-    const rawMemories = db.prepare("SELECT * FROM chunks" + where + ` ORDER BY created_at ${sortBy} LIMIT ? OFFSET ?`).all(...params, limit, offset);
+    const rawMemories = db.prepare("SELECT * FROM chunks" + where + ` ORDER BY CASE WHEN dedup_status IN ('duplicate','merged') THEN 1 ELSE 0 END ASC, created_at ${sortBy} LIMIT ? OFFSET ?`).all(...params, limit, offset);
     const findMergeSources = db.prepare("SELECT id, summary, role FROM chunks WHERE dedup_target = ? AND (dedup_status = 'merged' OR dedup_status = 'duplicate')");
 
     const chunkIds = rawMemories.map((m: any) => m.id);
     const sharingMap = new Map<string, { visibility: string; group_id: string | null }>();
+    const localShareMap = new Map<string, { original_owner: string; shared_at: number }>();
     if (chunkIds.length > 0) {
       try {
         const placeholders = chunkIds.map(() => "?").join(",");
         const sharedRows = db.prepare(`SELECT source_chunk_id, visibility, group_id FROM hub_memories WHERE source_chunk_id IN (${placeholders})`).all(...chunkIds) as Array<{ source_chunk_id: string; visibility: string; group_id: string | null }>;
         for (const r of sharedRows) sharingMap.set(r.source_chunk_id, r);
+        const localRows = db.prepare(`SELECT chunk_id, original_owner, shared_at FROM local_shared_memories WHERE chunk_id IN (${placeholders})`).all(...chunkIds) as Array<{ chunk_id: string; original_owner: string; shared_at: number }>;
+        for (const r of localRows) localShareMap.set(r.chunk_id, r);
       } catch {
       }
     }
@@ -457,8 +484,12 @@ export class ViewerServer {
         out.merge_sources = sources;
       }
       const shared = sharingMap.get(m.id);
+      const localShared = localShareMap.get(m.id);
       out.sharingVisibility = shared?.visibility ?? null;
       out.sharingGroupId = shared?.group_id ?? null;
+      out.localSharing = out.owner === "public";
+      out.localSharingManaged = !!localShared;
+      out.localOriginalOwner = localShared?.original_owner ?? null;
       return out;
     });
 
@@ -476,7 +507,21 @@ export class ViewerServer {
   }
 
   private serveToolMetrics(res: http.ServerResponse, url: URL): void {
-    const minutes = Math.min(1440, Math.max(10, Number(url.searchParams.get("minutes")) || 60));
+    const fromParam = url.searchParams.get("from");
+    const toParam = url.searchParams.get("to");
+    if (fromParam) {
+      const fromMs = new Date(fromParam).getTime();
+      const toMs = toParam ? new Date(toParam).getTime() : Date.now();
+      if (isNaN(fromMs) || isNaN(toMs)) {
+        this.jsonResponse(res, { error: "Invalid date" }, 400);
+        return;
+      }
+      const diffMin = Math.max(10, Math.min(43200, Math.round((toMs - fromMs) / 60000)));
+      const data = this.store.getToolMetrics(diffMin, fromMs, toMs);
+      this.jsonResponse(res, data);
+      return;
+    }
+    const minutes = Math.min(43200, Math.max(10, Number(url.searchParams.get("minutes")) || 60));
     const data = this.store.getToolMetrics(minutes);
     this.jsonResponse(res, data);
   }
@@ -484,13 +529,15 @@ export class ViewerServer {
   private serveTasks(res: http.ServerResponse, url: URL): void {
     this.store.recordViewerEvent("tasks_list");
     const status = url.searchParams.get("status") ?? undefined;
+    const owner = url.searchParams.get("owner") ?? undefined;
     const limit = Math.min(100, Math.max(1, Number(url.searchParams.get("limit")) || 50));
     const offset = Math.max(0, Number(url.searchParams.get("offset")) || 0);
-    const { tasks, total } = this.store.listTasks({ status, limit, offset });
+    const { tasks, total } = this.store.listTasks({ status, limit, offset, owner });
 
     const db = (this.store as any).db;
     const items = tasks.map((t) => {
-      const meta = db.prepare("SELECT skill_status FROM tasks WHERE id = ?").get(t.id) as { skill_status: string | null } | undefined;
+      const meta = db.prepare("SELECT skill_status, owner FROM tasks WHERE id = ?").get(t.id) as { skill_status: string | null; owner: string | null } | undefined;
+      const sharedTask = db.prepare("SELECT visibility FROM hub_tasks WHERE source_task_id = ? ORDER BY updated_at DESC LIMIT 1").get(t.id) as { visibility: string } | undefined;
       return {
         id: t.id,
         sessionKey: t.sessionKey,
@@ -501,6 +548,8 @@ export class ViewerServer {
         endedAt: t.endedAt,
         chunkCount: this.store.countChunksByTask(t.id),
         skillStatus: meta?.skill_status ?? null,
+        owner: meta?.owner ?? "agent:main",
+        sharingVisibility: sharedTask?.visibility ?? null,
       };
     });
 
@@ -543,6 +592,7 @@ export class ViewerServer {
       title: task.title,
       summary: task.summary,
       status: task.status,
+      owner: task.owner ?? "agent:main",
       startedAt: task.startedAt,
       endedAt: task.endedAt,
       chunks: chunkItems,
@@ -551,6 +601,7 @@ export class ViewerServer {
       skillLinks,
       sharingVisibility: sharedTask?.visibility ?? null,
       sharingGroupId: sharedTask?.group_id ?? null,
+      hubTaskId: sharedTask ? true : false,
     });
   }
 
@@ -585,12 +636,19 @@ export class ViewerServer {
       }
       let embCount = 0;
       try { embCount = (db.prepare("SELECT COUNT(*) as count FROM embeddings").get() as any).count; } catch { /* table may not exist */ }
-      const sessionQuery = ownerFilter
-        ? "SELECT session_key, COUNT(*) as count, MIN(created_at) as earliest, MAX(created_at) as latest FROM chunks WHERE owner = ? GROUP BY session_key ORDER BY latest DESC"
-        : "SELECT session_key, COUNT(*) as count, MIN(created_at) as earliest, MAX(created_at) as latest FROM chunks GROUP BY session_key ORDER BY latest DESC";
-      const sessionList = (ownerFilter
-        ? db.prepare(sessionQuery).all(ownerFilter)
-        : db.prepare(sessionQuery).all()) as any[];
+      let sessionQuery: string;
+      let sessionParams: any[];
+      if (ownerFilter && ownerFilter.startsWith("agent:")) {
+        sessionQuery = "SELECT session_key, COUNT(*) as count, MIN(created_at) as earliest, MAX(created_at) as latest FROM chunks WHERE (owner = ? OR owner = 'public') GROUP BY session_key ORDER BY latest DESC";
+        sessionParams = [ownerFilter];
+      } else if (ownerFilter) {
+        sessionQuery = "SELECT session_key, COUNT(*) as count, MIN(created_at) as earliest, MAX(created_at) as latest FROM chunks WHERE owner = ? GROUP BY session_key ORDER BY latest DESC";
+        sessionParams = [ownerFilter];
+      } else {
+        sessionQuery = "SELECT session_key, COUNT(*) as count, MIN(created_at) as earliest, MAX(created_at) as latest FROM chunks GROUP BY session_key ORDER BY latest DESC";
+        sessionParams = [];
+      }
+      const sessionList = db.prepare(sessionQuery).all(...sessionParams) as any[];
 
       let skillCount = 0;
       try { skillCount = (db.prepare("SELECT COUNT(*) as count FROM skills").get() as any).count; } catch { /* table may not exist yet */ }
@@ -603,10 +661,16 @@ export class ViewerServer {
 
       let owners: string[] = [];
       try {
-        const ownerRows = db.prepare("SELECT DISTINCT owner FROM chunks WHERE owner IS NOT NULL ORDER BY owner").all() as any[];
+        const ownerRows = db.prepare("SELECT DISTINCT owner FROM chunks WHERE owner IS NOT NULL AND owner LIKE 'agent:%' ORDER BY owner").all() as any[];
         owners = ownerRows.map((o: any) => o.owner);
       } catch { /* column may not exist yet */ }
 
+      let currentAgentOwner = "agent:main";
+      try {
+        const latest = db.prepare("SELECT owner FROM chunks WHERE owner IS NOT NULL AND owner LIKE 'agent:%' ORDER BY created_at DESC LIMIT 1").get() as any;
+        if (latest?.owner) currentAgentOwner = latest.owner;
+      } catch { /* best-effort */ }
+
       this.jsonResponse(res, {
         totalMemories: total.count, totalSessions: sessions.count, totalEmbeddings: embCount,
         totalSkills: skillCount,
@@ -615,6 +679,7 @@ export class ViewerServer {
         timeRange: { earliest: timeRange.earliest, latest: timeRange.latest },
         sessions: sessionList,
         owners,
+        currentAgentOwner,
       });
     } catch (e) {
       this.log.warn(`stats error: ${e}`);
@@ -726,7 +791,12 @@ export class ViewerServer {
     if (visibility) {
       skills = skills.filter(s => s.visibility === visibility);
     }
-    this.jsonResponse(res, { skills });
+    const db = (this.store as any).db;
+    const enriched = skills.map(s => {
+      const hub = db.prepare("SELECT visibility FROM hub_skills WHERE source_skill_id = ? ORDER BY updated_at DESC LIMIT 1").get(s.id) as { visibility: string } | undefined;
+      return { ...s, sharingVisibility: hub?.visibility ?? null };
+    });
+    this.jsonResponse(res, { skills: enriched });
   }
 
   private serveSkillDetail(res: http.ServerResponse, urlPath: string): void {
@@ -977,11 +1047,21 @@ export class ViewerServer {
     });
   }
 
-  private handleSkillDelete(res: http.ServerResponse, urlPath: string): void {
+  private async handleSkillDelete(res: http.ServerResponse, urlPath: string): Promise<void> {
     const skillId = urlPath.replace("/api/skill/", "");
     const skill = this.store.getSkill(skillId);
     if (!skill) { res.writeHead(404, { "Content-Type": "application/json" }); res.end(JSON.stringify({ error: "Skill not found" })); return; }
-    // Remove skill directory from disk
+    try {
+      const hub = this.resolveHubConnection();
+      if (hub) {
+        await hubRequestJson(hub.hubUrl, hub.userToken, "/api/v1/hub/skills/unpublish", {
+          method: "POST",
+          body: JSON.stringify({ sourceSkillId: skillId }),
+        }).catch(() => {});
+      }
+      const db = (this.store as any).db;
+      db.prepare("DELETE FROM hub_skills WHERE source_skill_id = ?").run(skillId);
+    } catch (_) {}
     try {
       if (skill.dirPath && fs.existsSync(skill.dirPath)) {
         fs.rmSync(skill.dirPath, { recursive: true, force: true });
@@ -1028,7 +1108,15 @@ export class ViewerServer {
     const cleaned = chunk.role === "user" && chunk.content
       ? { ...chunk, content: stripInboundMetadata(chunk.content) }
       : chunk;
-    this.jsonResponse(res, { memory: cleaned });
+    const localShared = this.store.getLocalSharedMemory(chunkId);
+    this.jsonResponse(res, {
+      memory: {
+        ...cleaned,
+        localSharing: cleaned.owner === "public",
+        localSharingManaged: !!localShared,
+        localOriginalOwner: localShared?.originalOwner ?? null,
+      },
+    });
   }
 
   private handleUpdate(req: http.IncomingMessage, res: http.ServerResponse, urlPath: string): void {
@@ -1057,6 +1145,349 @@ export class ViewerServer {
     else { res.writeHead(404, { "Content-Type": "application/json" }); res.end(JSON.stringify({ error: "Not found" })); }
   }
 
+  private handleMemoryLocalShare(req: http.IncomingMessage, res: http.ServerResponse): void {
+    this.readBody(req, (body) => {
+      try {
+        const parsed = JSON.parse(body || "{}");
+        const chunkId = String(parsed.chunkId || "");
+        if (!chunkId) return this.jsonResponse(res, { ok: false, error: "missing_chunk_id" }, 400);
+        const result = this.store.markMemorySharedLocally(chunkId);
+        if (!result.ok) {
+          return this.jsonResponse(res, { ok: false, error: result.reason ?? "share_failed" }, result.reason === "not_found" ? 404 : 400);
+        }
+        this.jsonResponse(res, {
+          ok: true,
+          chunkId,
+          owner: result.owner,
+          localSharing: true,
+          localSharingManaged: true,
+          localOriginalOwner: result.originalOwner ?? null,
+        });
+      } catch (err) {
+        this.jsonResponse(res, { ok: false, error: String(err) }, 400);
+      }
+    });
+  }
+
+  private handleMemoryLocalUnshare(req: http.IncomingMessage, res: http.ServerResponse): void {
+    this.readBody(req, (body) => {
+      try {
+        const parsed = JSON.parse(body || "{}");
+        const chunkId = String(parsed.chunkId || "");
+        const privateOwner = typeof parsed.privateOwner === "string" ? parsed.privateOwner : undefined;
+        if (!chunkId) return this.jsonResponse(res, { ok: false, error: "missing_chunk_id" }, 400);
+        const result = this.store.unmarkMemorySharedLocally(chunkId, privateOwner);
+        if (!result.ok) {
+          return this.jsonResponse(res, { ok: false, error: result.reason ?? "unshare_failed" }, result.reason === "not_found" ? 404 : 400);
+        }
+        this.jsonResponse(res, {
+          ok: true,
+          chunkId,
+          owner: result.owner,
+          localSharing: false,
+          localOriginalOwner: result.originalOwner ?? null,
+        });
+      } catch (err) {
+        this.jsonResponse(res, { ok: false, error: String(err) }, 400);
+      }
+    });
+  }
+
+  // ─── Unified scope API ───
+
+  private handleMemoryScope(req: http.IncomingMessage, res: http.ServerResponse, urlPath: string): void {
+    const chunkId = urlPath.split("/")[3];
+    this.readBody(req, async (body) => {
+      try {
+        const parsed = JSON.parse(body || "{}");
+        const scope = parsed.scope as string;
+        if (!["private", "local", "team"].includes(scope)) {
+          return this.jsonResponse(res, { ok: false, error: "scope must be 'private', 'local', or 'team'" }, 400);
+        }
+        const db = (this.store as any).db;
+        const chunk = db.prepare("SELECT * FROM chunks WHERE id = ?").get(chunkId) as any;
+        if (!chunk) return this.jsonResponse(res, { ok: false, error: "not_found" }, 404);
+
+        if (chunk.dedup_status && chunk.dedup_status !== "active") {
+          return this.jsonResponse(res, { ok: false, error: "inactive_memory", message: "Merged/duplicate memories cannot be shared" }, 400);
+        }
+
+        const isLocalShared = chunk.owner === "public";
+        const hubMemory = this.getHubMemoryForChunk(chunkId);
+        const isTeamShared = !!hubMemory;
+        const currentScope = isTeamShared ? "team" : isLocalShared ? "local" : "private";
+
+        if (scope === currentScope) {
+          return this.jsonResponse(res, { ok: true, scope, changed: false });
+        }
+
+        let hubSynced = false;
+
+        if (scope === "team") {
+          if (!isTeamShared) {
+            const hubClient = await this.resolveHubClientAware();
+            const refreshedChunk = db.prepare("SELECT * FROM chunks WHERE id = ?").get(chunkId) as any;
+            const response = await hubRequestJson(hubClient.hubUrl, hubClient.userToken, "/api/v1/hub/memories/share", {
+              method: "POST",
+              body: JSON.stringify({ memory: { sourceChunkId: refreshedChunk.id, role: refreshedChunk.role, content: refreshedChunk.content, summary: refreshedChunk.summary, kind: refreshedChunk.kind, groupId: null, visibility: "public" } }),
+            });
+            if (!isLocalShared) this.store.markMemorySharedLocally(chunkId);
+            if (hubClient.userId) {
+              const existing = this.store.getHubMemoryBySource(hubClient.userId, chunkId);
+              this.store.upsertHubMemory({
+                id: (response as any)?.memoryId ?? existing?.id ?? crypto.randomUUID(),
+                sourceChunkId: chunkId, sourceUserId: hubClient.userId,
+                role: refreshedChunk.role, content: refreshedChunk.content, summary: refreshedChunk.summary ?? "",
+                kind: refreshedChunk.kind, groupId: null, visibility: "public",
+                createdAt: existing?.createdAt ?? Date.now(), updatedAt: Date.now(),
+              });
+            }
+            hubSynced = true;
+          } else {
+            if (!isLocalShared) this.store.markMemorySharedLocally(chunkId);
+          }
+        } else if (scope === "local") {
+          if (isTeamShared) {
+            try {
+              const hubClient = await this.resolveHubClientAware();
+              await hubRequestJson(hubClient.hubUrl, hubClient.userToken, "/api/v1/hub/memories/unshare", {
+                method: "POST", body: JSON.stringify({ sourceChunkId: chunkId }),
+              });
+              if (hubClient.userId) this.store.deleteHubMemoryBySource(hubClient.userId, chunkId);
+              hubSynced = true;
+            } catch (err) { this.log.warn(`Failed to unshare memory from team: ${err}`); }
+          }
+          if (!isLocalShared) this.store.markMemorySharedLocally(chunkId);
+        } else {
+          if (isTeamShared) {
+            try {
+              const hubClient = await this.resolveHubClientAware();
+              await hubRequestJson(hubClient.hubUrl, hubClient.userToken, "/api/v1/hub/memories/unshare", {
+                method: "POST", body: JSON.stringify({ sourceChunkId: chunkId }),
+              });
+              if (hubClient.userId) this.store.deleteHubMemoryBySource(hubClient.userId, chunkId);
+              hubSynced = true;
+            } catch (err) { this.log.warn(`Failed to unshare memory from team: ${err}`); }
+          }
+          if (isLocalShared) this.store.unmarkMemorySharedLocally(chunkId);
+        }
+
+        this.jsonResponse(res, { ok: true, scope, changed: true, hubSynced });
+      } catch (err) {
+        this.jsonResponse(res, { ok: false, error: String(err) }, 500);
+      }
+    });
+  }
+
+  private handleTaskScope(req: http.IncomingMessage, res: http.ServerResponse, urlPath: string): void {
+    const taskId = urlPath.split("/")[3];
+    this.readBody(req, async (body) => {
+      try {
+        const parsed = JSON.parse(body || "{}");
+        const scope = parsed.scope as string;
+        if (!["private", "local", "team"].includes(scope)) {
+          return this.jsonResponse(res, { ok: false, error: "scope must be 'private', 'local', or 'team'" }, 400);
+        }
+        const task = this.store.getTask(taskId);
+        if (!task) return this.jsonResponse(res, { ok: false, error: "task_not_found" }, 404);
+
+        if (scope !== "private" && task.status !== "completed") {
+          return this.jsonResponse(res, { ok: false, error: "only_completed_tasks_can_be_shared" }, 400);
+        }
+
+        const isLocalShared = task.owner === "public";
+        const hubTask = this.getHubTaskForLocal(taskId);
+        const isTeamShared = !!hubTask;
+        const currentScope = isTeamShared ? "team" : isLocalShared ? "local" : "private";
+
+        if (scope === currentScope) {
+          return this.jsonResponse(res, { ok: true, scope, changed: false });
+        }
+
+        let hubSynced = false;
+
+        if (scope === "team") {
+          if (!isTeamShared) {
+            const chunks = this.store.getChunksByTask(taskId);
+            const hubClient = await this.resolveHubClientAware();
+            const refreshedTask = this.store.getTask(taskId)!;
+            const response = await hubRequestJson(hubClient.hubUrl, hubClient.userToken, "/api/v1/hub/tasks/share", {
+              method: "POST",
+              body: JSON.stringify({
+                task: { id: refreshedTask.id, sourceTaskId: refreshedTask.id, title: refreshedTask.title, summary: refreshedTask.summary, groupId: null, visibility: "public", createdAt: refreshedTask.startedAt ?? Date.now(), updatedAt: refreshedTask.updatedAt ?? Date.now() },
+                chunks: chunks.map((c) => ({ id: c.id, hubTaskId: refreshedTask.id, sourceTaskId: refreshedTask.id, sourceChunkId: c.id, role: c.role, content: c.content, summary: c.summary, kind: c.kind, groupId: null, visibility: "public", createdAt: c.createdAt ?? Date.now() })),
+              }),
+            });
+            if (hubClient.userId) {
+              const existing = this.store.getHubTaskBySource(hubClient.userId, taskId);
+              this.store.upsertHubTask({
+                id: (response as any)?.taskId ?? existing?.id ?? crypto.randomUUID(),
+                sourceTaskId: taskId, sourceUserId: hubClient.userId, title: refreshedTask.title ?? "",
+                summary: refreshedTask.summary ?? "", groupId: null, visibility: "public",
+                createdAt: existing?.createdAt ?? Date.now(), updatedAt: Date.now(),
+              });
+            }
+            hubSynced = true;
+          }
+          if (!isLocalShared) {
+            const originalOwner = task.owner;
+            const db = (this.store as any).db;
+            db.prepare("INSERT INTO local_shared_tasks (task_id, hub_task_id, original_owner, shared_at) VALUES (?, ?, ?, ?) ON CONFLICT(task_id) DO UPDATE SET original_owner = excluded.original_owner, shared_at = excluded.shared_at").run(taskId, "", originalOwner, Date.now());
+            db.prepare("UPDATE tasks SET owner = 'public' WHERE id = ?").run(taskId);
+          }
+        }
+
+        if (scope === "local") {
+          if (!isLocalShared) {
+            const originalOwner = task.owner;
+            const db = (this.store as any).db;
+            db.prepare("INSERT INTO local_shared_tasks (task_id, hub_task_id, original_owner, shared_at) VALUES (?, ?, ?, ?) ON CONFLICT(task_id) DO UPDATE SET original_owner = excluded.original_owner, shared_at = excluded.shared_at").run(taskId, "", originalOwner, Date.now());
+            db.prepare("UPDATE tasks SET owner = 'public' WHERE id = ?").run(taskId);
+          }
+        }
+
+        if (scope === "local" && isTeamShared) {
+          try {
+            const hubClient = await this.resolveHubClientAware();
+            await hubRequestJson(hubClient.hubUrl, hubClient.userToken, "/api/v1/hub/tasks/unshare", {
+              method: "POST", body: JSON.stringify({ sourceTaskId: taskId }),
+            });
+            if (hubClient.userId) this.store.deleteHubTaskBySource(hubClient.userId, taskId);
+            hubSynced = true;
+          } catch (err) { this.log.warn(`Failed to unshare task from team: ${err}`); }
+        }
+
+        if (scope === "private") {
+          if (isTeamShared) {
+            try {
+              const hubClient = await this.resolveHubClientAware();
+              await hubRequestJson(hubClient.hubUrl, hubClient.userToken, "/api/v1/hub/tasks/unshare", {
+                method: "POST", body: JSON.stringify({ sourceTaskId: taskId }),
+              });
+              if (hubClient.userId) this.store.deleteHubTaskBySource(hubClient.userId, taskId);
+              hubSynced = true;
+            } catch (err) { this.log.warn(`Failed to unshare task from team: ${err}`); }
+          }
+          if (isLocalShared) {
+            const db = (this.store as any).db;
+            const shared = db.prepare("SELECT original_owner FROM local_shared_tasks WHERE task_id = ?").get(taskId) as any;
+            const restoreOwner = shared?.original_owner ?? task.owner;
+            if (restoreOwner && restoreOwner !== "public") {
+              db.prepare("UPDATE tasks SET owner = ? WHERE id = ?").run(restoreOwner, taskId);
+            }
+            db.prepare("DELETE FROM local_shared_tasks WHERE task_id = ?").run(taskId);
+          }
+        }
+
+        this.jsonResponse(res, { ok: true, scope, changed: true, hubSynced });
+      } catch (err) {
+        this.jsonResponse(res, { ok: false, error: String(err) }, 500);
+      }
+    });
+  }
+
+  private handleSkillScope(req: http.IncomingMessage, res: http.ServerResponse, urlPath: string): void {
+    const skillId = urlPath.split("/")[3];
+    this.readBody(req, async (body) => {
+      try {
+        const parsed = JSON.parse(body || "{}");
+        const scope = parsed.scope as string;
+        if (!["private", "local", "team"].includes(scope)) {
+          return this.jsonResponse(res, { ok: false, error: "scope must be 'private', 'local', or 'team'" }, 400);
+        }
+        const skill = this.store.getSkill(skillId);
+        if (!skill) return this.jsonResponse(res, { ok: false, error: "skill_not_found" }, 404);
+
+        if (scope !== "private" && skill.status !== "active") {
+          return this.jsonResponse(res, { ok: false, error: "only_active_skills_can_be_shared" }, 400);
+        }
+
+        const isLocalShared = skill.visibility === "public";
+        const hubSkill = this.getHubSkillForLocal(skillId);
+        const isTeamShared = !!hubSkill;
+        const currentScope = isTeamShared ? "team" : isLocalShared ? "local" : "private";
+
+        if (scope === currentScope) {
+          return this.jsonResponse(res, { ok: true, scope, changed: false });
+        }
+
+        let hubSynced = false;
+
+        if (scope === "team") {
+          if (!isTeamShared) {
+            const bundle = buildSkillBundleForHub(this.store, skillId);
+            const hubClient = await this.resolveHubClientAware();
+            const response = await hubRequestJson(hubClient.hubUrl, hubClient.userToken, "/api/v1/hub/skills/publish", {
+              method: "POST",
+              body: JSON.stringify({ visibility: "public", groupId: null, metadata: bundle.metadata, bundle: bundle.bundle }),
+            });
+            if (hubClient.userId) {
+              const existing = this.store.getHubSkillBySource(hubClient.userId, skillId);
+              this.store.upsertHubSkill({
+                id: (response as any)?.skillId ?? existing?.id ?? crypto.randomUUID(),
+                sourceSkillId: skillId, sourceUserId: hubClient.userId,
+                name: skill.name, description: skill.description, version: skill.version,
+                groupId: null, visibility: "public",
+                bundle: JSON.stringify(bundle.bundle), qualityScore: skill.qualityScore,
+                createdAt: existing?.createdAt ?? Date.now(), updatedAt: Date.now(),
+              });
+            }
+            hubSynced = true;
+          }
+          if (!isLocalShared) this.store.setSkillVisibility(skillId, "public");
+        }
+
+        if (scope === "local") {
+          if (!isLocalShared) this.store.setSkillVisibility(skillId, "public");
+        }
+
+        if (scope === "local" && isTeamShared) {
+          try {
+            const hubClient = await this.resolveHubClientAware();
+            await hubRequestJson(hubClient.hubUrl, hubClient.userToken, "/api/v1/hub/skills/unpublish", {
+              method: "POST", body: JSON.stringify({ sourceSkillId: skillId }),
+            });
+            if (hubClient.userId) this.store.deleteHubSkillBySource(hubClient.userId, skillId);
+            hubSynced = true;
+          } catch (err) { this.log.warn(`Failed to unpublish skill from team: ${err}`); }
+        }
+
+        if (scope === "private") {
+          if (isTeamShared) {
+            try {
+              const hubClient = await this.resolveHubClientAware();
+              await hubRequestJson(hubClient.hubUrl, hubClient.userToken, "/api/v1/hub/skills/unpublish", {
+                method: "POST", body: JSON.stringify({ sourceSkillId: skillId }),
+              });
+              if (hubClient.userId) this.store.deleteHubSkillBySource(hubClient.userId, skillId);
+              hubSynced = true;
+            } catch (err) { this.log.warn(`Failed to unpublish skill from team: ${err}`); }
+          }
+          if (isLocalShared) this.store.setSkillVisibility(skillId, "private");
+        }
+
+        this.jsonResponse(res, { ok: true, scope, changed: true, hubSynced });
+      } catch (err) {
+        this.jsonResponse(res, { ok: false, error: String(err) }, 500);
+      }
+    });
+  }
+
+  private getHubMemoryForChunk(chunkId: string): any {
+    const db = (this.store as any).db;
+    return db.prepare("SELECT * FROM hub_memories WHERE source_chunk_id = ? LIMIT 1").get(chunkId);
+  }
+
+  private getHubTaskForLocal(taskId: string): any {
+    const db = (this.store as any).db;
+    return db.prepare("SELECT * FROM hub_tasks WHERE source_task_id = ? LIMIT 1").get(taskId);
+  }
+
+  private getHubSkillForLocal(skillId: string): any {
+    const db = (this.store as any).db;
+    return db.prepare("SELECT * FROM hub_skills WHERE source_skill_id = ? LIMIT 1").get(skillId);
+  }
+
   private handleDeleteSession(res: http.ServerResponse, url: URL): void {
     const key = url.searchParams.get("key");
     if (!key) { res.writeHead(400, { "Content-Type": "application/json" }); res.end(JSON.stringify({ error: "Missing key" })); return; }
@@ -1092,7 +1523,8 @@ export class ViewerServer {
 
   private getOpenClawConfigPath(): string {
     const home = process.env.HOME || process.env.USERPROFILE || "";
-    return path.join(home, ".openclaw", "openclaw.json");
+    const ocHome = process.env.OPENCLAW_STATE_DIR || path.join(home, ".openclaw");
+    return path.join(ocHome, "openclaw.json");
   }
 
   private getPluginEntryConfig(raw: any): Record<string, unknown> {
@@ -1156,8 +1588,7 @@ export class ViewerServer {
       base.connection.connected = true;
       base.connection.hubUrl = resolvedHubUrl ?? undefined;
 
-      // 通过 hub API 获取 admin 用户的真实信息（含分组）
-      let adminUser: any = { username: "hub-admin", role: "admin", groups: [] };
+      let adminUser: any = { username: "hub-admin", role: "admin" };
       try {
         const hub = this.resolveHubConnection();
         if (hub) {
@@ -1167,7 +1598,6 @@ export class ViewerServer {
               id: me.id,
               username: me.username ?? "hub-admin",
               role: me.role ?? "admin",
-              groups: Array.isArray(me.groups) ? me.groups : [],
             };
           }
         }
@@ -1185,7 +1615,8 @@ export class ViewerServer {
       return;
     }
 
-    if (!hasClientConfig) {
+    const hasPendingConnection = Boolean(persisted?.hubUrl && persisted?.userId && !persisted?.userToken);
+    if (!hasClientConfig && !hasPendingConnection) {
       this.jsonResponse(res, base);
       return;
     }
@@ -1193,12 +1624,26 @@ export class ViewerServer {
     try {
       const status = await getHubStatus(this.store, this.ctx.config);
       const output = { ...base, connection: { ...base.connection, ...status } } as any;
+      if (status.user?.status === "pending") {
+        output.connection.pendingApproval = true;
+      }
+      if (status.user?.status === "rejected") {
+        output.connection.rejected = true;
+      }
+      if (status.user?.status === "removed") {
+        output.connection.removed = true;
+      }
       if (status.connected && status.hubUrl) {
         try {
           const info = await fetch(`${status.hubUrl}/api/v1/hub/info`).then((r) => (r.ok ? r.json() : null)).catch(() => null) as any;
           output.connection.teamName = info?.teamName ?? null;
           output.connection.apiVersion = info?.apiVersion ?? null;
         } catch {}
+      } else if (status.hubUrl) {
+        try {
+          const info = await fetch(`${status.hubUrl}/api/v1/hub/info`).then((r) => (r.ok ? r.json() : null)).catch(() => null) as any;
+          output.connection.teamName = info?.teamName ?? null;
+        } catch {}
       }
       output.admin.canManageUsers = status.connected && status.user?.role === "admin";
       output.admin.rejectSupported = output.admin.canManageUsers;
@@ -1256,11 +1701,123 @@ export class ViewerServer {
     });
   }
 
+  private handleSharingChangeRole(req: http.IncomingMessage, res: http.ServerResponse): void {
+    this.readBody(req, async (body) => {
+      if (!this.ctx) return this.jsonResponse(res, { ok: false, error: "sharing_unavailable" });
+      try {
+        const parsed = JSON.parse(body || "{}");
+        const hub = this.resolveHubConnection();
+        if (!hub) return this.jsonResponse(res, { ok: false, error: "not_configured" });
+        const result = await hubRequestJson(hub.hubUrl, hub.userToken, "/api/v1/hub/admin/change-role", {
+          method: "POST",
+          body: JSON.stringify({ userId: parsed.userId, role: parsed.role }),
+        });
+        this.jsonResponse(res, { ok: true, result });
+      } catch (err) {
+        this.jsonResponse(res, { ok: false, error: String(err) });
+      }
+    });
+  }
+
+  private handleSharingRemoveUser(req: http.IncomingMessage, res: http.ServerResponse): void {
+    this.readBody(req, async (body) => {
+      if (!this.ctx) return this.jsonResponse(res, { ok: false, error: "sharing_unavailable" });
+      try {
+        const parsed = JSON.parse(body || "{}");
+        const hub = this.resolveHubConnection();
+        if (!hub) return this.jsonResponse(res, { ok: false, error: "not_configured" });
+        const result = await hubRequestJson(hub.hubUrl, hub.userToken, "/api/v1/hub/admin/remove-user", {
+          method: "POST",
+          body: JSON.stringify({ userId: parsed.userId, cleanResources: parsed.cleanResources === true }),
+        });
+        this.jsonResponse(res, { ok: true, result });
+      } catch (err) {
+        this.jsonResponse(res, { ok: false, error: String(err) });
+      }
+    });
+  }
+
+  private handleAdminRenameUser(req: http.IncomingMessage, res: http.ServerResponse): void {
+    this.readBody(req, async (body) => {
+      if (!this.ctx) return this.jsonResponse(res, { ok: false, error: "sharing_unavailable" });
+      try {
+        const parsed = JSON.parse(body || "{}");
+        const hub = this.resolveHubConnection();
+        if (!hub) return this.jsonResponse(res, { ok: false, error: "not_configured" });
+        const result = await hubRequestJson(hub.hubUrl, hub.userToken, "/api/v1/hub/admin/rename-user", {
+          method: "POST",
+          body: JSON.stringify({ userId: parsed.userId, username: parsed.username }),
+        });
+        this.jsonResponse(res, { ok: true, result });
+      } catch (err) {
+        const errStr = String(err);
+        if (errStr.includes("username_taken")) {
+          this.jsonResponse(res, { ok: false, error: "username_taken" });
+        } else if (errStr.includes("invalid_params")) {
+          this.jsonResponse(res, { ok: false, error: "invalid_params" });
+        } else {
+          this.jsonResponse(res, { ok: false, error: errStr });
+        }
+      }
+    });
+  }
+
+  private handleRetryJoin(req: http.IncomingMessage, res: http.ServerResponse): void {
+    this.readBody(req, async (_body) => {
+      if (!this.ctx) return this.jsonResponse(res, { ok: false, error: "sharing_unavailable" });
+      const sharing = this.ctx.config.sharing;
+      if (!sharing?.enabled || sharing.role !== "client") {
+        return this.jsonResponse(res, { ok: false, error: "not_in_client_mode" });
+      }
+      const hubAddress = sharing.client?.hubAddress ?? "";
+      const teamToken = sharing.client?.teamToken ?? "";
+      if (!hubAddress || !teamToken) {
+        return this.jsonResponse(res, { ok: false, error: "missing_hub_address_or_team_token" });
+      }
+      try {
+        const hubUrl = normalizeHubUrl(hubAddress);
+        const localIPs = this.getLocalIPs();
+        localIPs.push("127.0.0.1", "localhost", "0.0.0.0");
+        try {
+          const u = new URL(hubUrl);
+          if (localIPs.includes(u.hostname)) {
+            return this.jsonResponse(res, { ok: false, error: "cannot_join_self" });
+          }
+        } catch {}
+        const os = await import("os");
+        const nickname = sharing.client?.nickname;
+        const username = nickname || os.userInfo().username || "user";
+        const hostname = os.hostname() || "unknown";
+        const result = await hubRequestJson(hubUrl, "", "/api/v1/hub/join", {
+          method: "POST",
+          body: JSON.stringify({ teamToken, username, deviceName: hostname, reapply: true }),
+        }) as any;
+        this.store.setClientHubConnection({
+          hubUrl,
+          userId: String(result.userId || ""),
+          username,
+          userToken: result.userToken || "",
+          role: "member",
+          connectedAt: Date.now(),
+        });
+        this.jsonResponse(res, { ok: true, status: result.status || "pending" });
+      } catch (err) {
+        this.jsonResponse(res, { ok: false, error: String(err) });
+      }
+    });
+  }
+
   private async serveSharingMemoryList(res: http.ServerResponse, url: URL): Promise<void> {
     if (!this.ctx) return this.jsonResponse(res, { memories: [], error: "sharing_unavailable" });
     try {
       const limit = Number(url.searchParams.get("limit") || 40);
-      const data = await hubListMemories(this.store, this.ctx, { limit });
+      const hub = this.resolveHubConnection();
+      let data: any;
+      if (hub) {
+        data = await hubRequestJson(hub.hubUrl, hub.userToken, `/api/v1/hub/memories?limit=${limit}`);
+      } else {
+        data = await hubListMemories(this.store, this.ctx, { limit });
+      }
       this.jsonResponse(res, { memories: Array.isArray(data?.memories) ? data.memories : [] });
     } catch (err) {
       this.jsonResponse(res, { memories: [], error: String(err) });
@@ -1271,7 +1828,13 @@ export class ViewerServer {
     if (!this.ctx) return this.jsonResponse(res, { tasks: [], error: "sharing_unavailable" });
     try {
       const limit = Number(url.searchParams.get("limit") || 40);
-      const data = await hubListTasks(this.store, this.ctx, { limit });
+      const hub = this.resolveHubConnection();
+      let data: any;
+      if (hub) {
+        data = await hubRequestJson(hub.hubUrl, hub.userToken, `/api/v1/hub/tasks?limit=${limit}`);
+      } else {
+        data = await hubListTasks(this.store, this.ctx, { limit });
+      }
       this.jsonResponse(res, { tasks: Array.isArray(data?.tasks) ? data.tasks : [] });
     } catch (err) {
       this.jsonResponse(res, { tasks: [], error: String(err) });
@@ -1282,7 +1845,13 @@ export class ViewerServer {
     if (!this.ctx) return this.jsonResponse(res, { skills: [], error: "sharing_unavailable" });
     try {
       const limit = Number(url.searchParams.get("limit") || 40);
-      const data = await hubListSkills(this.store, this.ctx, { limit });
+      const hub = this.resolveHubConnection();
+      let data: any;
+      if (hub) {
+        data = await hubRequestJson(hub.hubUrl, hub.userToken, `/api/v1/hub/skills/list?limit=${limit}`);
+      } else {
+        data = await hubListSkills(this.store, this.ctx, { limit });
+      }
       this.jsonResponse(res, { skills: Array.isArray(data?.skills) ? data.skills : [] });
     } catch (err) {
       this.jsonResponse(res, { skills: [], error: String(err) });
@@ -1298,13 +1867,21 @@ export class ViewerServer {
         const query = String(parsed.query || "");
         const role = typeof parsed.role === "string" ? parsed.role : undefined;
         const maxResults = typeof parsed.maxResults === "number" ? parsed.maxResults : 10;
-        const scope = parsed.scope === "group" || parsed.scope === "all" ? parsed.scope : "local";
+        const scope = parsed.scope === "group" || parsed.scope === "all" || parsed.scope === "hub" ? (parsed.scope === "hub" ? "all" : parsed.scope) : "local";
         const local = this.searchLocalViewerMemories(query, { role, maxResults });
         if (scope === "local") {
           return this.jsonResponse(res, { local: { hits: local.hits, meta: local.meta }, hub: emptyHub });
         }
         try {
-          const hub = await hubSearchMemories(this.store, this.ctx, { query, maxResults, scope });
+          const conn = this.resolveHubConnection();
+          let hub: any;
+          if (conn) {
+            hub = await hubRequestJson(conn.hubUrl, conn.userToken, "/api/v1/hub/search", {
+              method: "POST", body: JSON.stringify({ query, maxResults, scope }),
+            });
+          } else {
+            hub = await hubSearchMemories(this.store, this.ctx!, { query, maxResults, scope });
+          }
           this.jsonResponse(res, { local: { hits: local.hits, meta: local.meta }, hub });
         } catch (err) {
           this.jsonResponse(res, { local: { hits: local.hits, meta: local.meta }, hub: emptyHub, error: String(err) });
@@ -1395,8 +1972,8 @@ export class ViewerServer {
       try {
         const parsed = JSON.parse(body || "{}");
         const taskId = String(parsed.taskId || "");
-        const visibility = parsed.visibility === "group" ? "group" : "public";
-        const groupId = typeof parsed.groupId === "string" ? parsed.groupId : undefined;
+        const visibility = "public";
+        const groupId: string | undefined = undefined;
         const task = this.store.getTask(taskId);
         if (!task) return this.jsonResponse(res, { ok: false, error: "task_not_found" });
         const chunks = this.store.getChunksByTask(taskId);
@@ -1410,7 +1987,7 @@ export class ViewerServer {
               sourceTaskId: task.id,
               title: task.title,
               summary: task.summary,
-              groupId: visibility === "group" ? groupId ?? null : null,
+              groupId: null,
               visibility,
               createdAt: task.startedAt ?? Date.now(),
               updatedAt: task.updatedAt ?? Date.now(),
@@ -1436,7 +2013,7 @@ export class ViewerServer {
             sourceUserId: hubUserId,
             title: task.title,
             summary: task.summary,
-            groupId: visibility === "group" ? groupId ?? null : null,
+            groupId: null,
             visibility,
             createdAt: task.startedAt ?? Date.now(),
             updatedAt: task.updatedAt ?? Date.now(),
@@ -1477,8 +2054,8 @@ export class ViewerServer {
       try {
         const parsed = JSON.parse(body || "{}");
         const chunkId = String(parsed.chunkId || "");
-        const visibility = parsed.visibility === "group" ? "group" : "public";
-        const groupId = typeof parsed.groupId === "string" ? parsed.groupId : undefined;
+        const visibility = "public";
+        const groupId: string | undefined = undefined;
         const db = (this.store as any).db;
         const chunk = db.prepare("SELECT * FROM chunks WHERE id = ?").get(chunkId) as any;
         if (!chunk) return this.jsonResponse(res, { ok: false, error: "memory_not_found" });
@@ -1492,7 +2069,7 @@ export class ViewerServer {
               content: chunk.content,
               summary: chunk.summary,
               kind: chunk.kind,
-              groupId: visibility === "group" ? groupId ?? null : null,
+              groupId: null,
               visibility,
             },
           }),
@@ -1509,7 +2086,7 @@ export class ViewerServer {
             content: chunk.content,
             summary: chunk.summary ?? "",
             kind: chunk.kind,
-            groupId: visibility === "group" ? groupId ?? null : null,
+            groupId: null,
             visibility,
             createdAt: existing?.createdAt ?? now,
             updatedAt: now,
@@ -1563,8 +2140,8 @@ export class ViewerServer {
       try {
         const parsed = JSON.parse(body || "{}");
         const skillId = String(parsed.skillId || "");
-        const visibility = parsed.visibility === "group" ? "group" : "public";
-        const groupId = parsed.groupId ? String(parsed.groupId) : null;
+        const visibility = "public";
+        const groupId: string | null = null;
         const skill = this.store.getSkill(skillId);
         if (!skill) return this.jsonResponse(res, { ok: false, error: "skill_not_found" });
         const bundle = buildSkillBundleForHub(this.store, skillId);
@@ -1573,7 +2150,7 @@ export class ViewerServer {
           method: "POST",
           body: JSON.stringify({
             visibility,
-            groupId: visibility === "group" ? groupId : null,
+            groupId: null,
             metadata: bundle.metadata,
             bundle: bundle.bundle,
           }),
@@ -1588,7 +2165,7 @@ export class ViewerServer {
             name: skill.name,
             description: skill.description,
             version: skill.version,
-            groupId: visibility === "group" ? groupId : null,
+            groupId: null,
             visibility,
             bundle: JSON.stringify(bundle.bundle),
             qualityScore: skill.qualityScore,
@@ -1671,117 +2248,6 @@ export class ViewerServer {
     return resolveHubClient(this.store, this.ctx);
   }
 
-  private extractGroupId(path: string): string {
-    const m = path.match(/\/api\/sharing\/groups\/([^/]+)/);
-    return m ? decodeURIComponent(m[1]) : "";
-  }
-
-  private async serveSharingGroups(res: http.ServerResponse): Promise<void> {
-    const hub = this.resolveHubConnection();
-    if (!hub) return this.jsonResponse(res, { groups: [], error: "not_configured" });
-    try {
-      const data = await hubRequestJson(hub.hubUrl, hub.userToken, "/api/v1/hub/groups", { method: "GET" }) as any;
-      this.jsonResponse(res, { groups: Array.isArray(data?.groups) ? data.groups : [] });
-    } catch (err) {
-      this.jsonResponse(res, { groups: [], error: String(err) });
-    }
-  }
-
-  private handleSharingGroupCreate(req: http.IncomingMessage, res: http.ServerResponse): void {
-    this.readBody(req, async (body) => {
-      const hub = this.resolveHubConnection();
-      if (!hub) return this.jsonResponse(res, { ok: false, error: "not_configured" });
-      try {
-        const parsed = JSON.parse(body || "{}");
-        const data = await hubRequestJson(hub.hubUrl, hub.userToken, "/api/v1/hub/groups", {
-          method: "POST",
-          body: JSON.stringify({ name: parsed.name, description: parsed.description }),
-        }) as any;
-        this.jsonResponse(res, { ok: true, ...data });
-      } catch (err) {
-        this.jsonResponse(res, { ok: false, error: String(err) });
-      }
-    });
-  }
-
-  private handleSharingGroupUpdate(req: http.IncomingMessage, res: http.ServerResponse, p: string): void {
-    this.readBody(req, async (body) => {
-      const hub = this.resolveHubConnection();
-      if (!hub) return this.jsonResponse(res, { ok: false, error: "not_configured" });
-      const groupId = this.extractGroupId(p);
-      try {
-        const parsed = JSON.parse(body || "{}");
-        await hubRequestJson(hub.hubUrl, hub.userToken, `/api/v1/hub/groups/${encodeURIComponent(groupId)}`, {
-          method: "PUT",
-          body: JSON.stringify({ name: parsed.name, description: parsed.description }),
-        });
-        this.jsonResponse(res, { ok: true });
-      } catch (err) {
-        this.jsonResponse(res, { ok: false, error: String(err) });
-      }
-    });
-  }
-
-  private async handleSharingGroupDelete(res: http.ServerResponse, p: string): Promise<void> {
-    const hub = this.resolveHubConnection();
-    if (!hub) return this.jsonResponse(res, { ok: false, error: "not_configured" });
-    const groupId = this.extractGroupId(p);
-    try {
-      await hubRequestJson(hub.hubUrl, hub.userToken, `/api/v1/hub/groups/${encodeURIComponent(groupId)}`, { method: "DELETE" });
-      this.jsonResponse(res, { ok: true });
-    } catch (err) {
-      this.jsonResponse(res, { ok: false, error: String(err) });
-    }
-  }
-
-  private async serveSharingGroupMembers(res: http.ServerResponse, p: string): Promise<void> {
-    const hub = this.resolveHubConnection();
-    if (!hub) return this.jsonResponse(res, { members: [], error: "not_configured" });
-    const groupId = this.extractGroupId(p);
-    try {
-      const data = await hubRequestJson(hub.hubUrl, hub.userToken, `/api/v1/hub/groups/${encodeURIComponent(groupId)}`, { method: "GET" }) as any;
-      this.jsonResponse(res, { members: Array.isArray(data?.members) ? data.members : [] });
-    } catch (err) {
-      this.jsonResponse(res, { members: [], error: String(err) });
-    }
-  }
-
-  private handleSharingGroupAddMember(req: http.IncomingMessage, res: http.ServerResponse, p: string): void {
-    this.readBody(req, async (body) => {
-      const hub = this.resolveHubConnection();
-      if (!hub) return this.jsonResponse(res, { ok: false, error: "not_configured" });
-      const groupId = this.extractGroupId(p);
-      try {
-        const parsed = JSON.parse(body || "{}");
-        await hubRequestJson(hub.hubUrl, hub.userToken, `/api/v1/hub/groups/${encodeURIComponent(groupId)}/members`, {
-          method: "POST",
-          body: JSON.stringify({ userId: parsed.userId }),
-        });
-        this.jsonResponse(res, { ok: true });
-      } catch (err) {
-        this.jsonResponse(res, { ok: false, error: String(err) });
-      }
-    });
-  }
-
-  private handleSharingGroupRemoveMember(req: http.IncomingMessage, res: http.ServerResponse, p: string): void {
-    this.readBody(req, async (body) => {
-      const hub = this.resolveHubConnection();
-      if (!hub) return this.jsonResponse(res, { ok: false, error: "not_configured" });
-      const groupId = this.extractGroupId(p);
-      try {
-        const parsed = JSON.parse(body || "{}");
-        await hubRequestJson(hub.hubUrl, hub.userToken, `/api/v1/hub/groups/${encodeURIComponent(groupId)}/members`, {
-          method: "DELETE",
-          body: JSON.stringify({ userId: parsed.userId }),
-        });
-        this.jsonResponse(res, { ok: true });
-      } catch (err) {
-        this.jsonResponse(res, { ok: false, error: String(err) });
-      }
-    });
-  }
-
   private async serveSharingUsers(res: http.ServerResponse): Promise<void> {
     const hub = this.resolveHubConnection();
     if (!hub) return this.jsonResponse(res, { users: [], error: "not_configured" });
@@ -1800,7 +2266,14 @@ export class ViewerServer {
     if (!hub) return this.jsonResponse(res, { tasks: [], error: "not_configured" });
     try {
       const data = await hubRequestJson(hub.hubUrl, hub.userToken, "/api/v1/hub/admin/shared-tasks", { method: "GET" }) as any;
-      this.jsonResponse(res, { tasks: Array.isArray(data?.tasks) ? data.tasks : [] });
+      const tasks = Array.isArray(data?.tasks) ? data.tasks : [];
+      for (const tk of tasks) {
+        if (!tk.summary && tk.sourceTaskId) {
+          const local = this.store.getTask(tk.sourceTaskId);
+          if (local) { tk.summary = local.summary; tk.title = tk.title || local.title; }
+        }
+      }
+      this.jsonResponse(res, { tasks });
     } catch (err) {
       this.jsonResponse(res, { tasks: [], error: String(err) });
     }
@@ -1818,12 +2291,47 @@ export class ViewerServer {
     }
   }
 
+  private async serveHubTaskDetail(res: http.ServerResponse, p: string): Promise<void> {
+    const hub = this.resolveHubConnection();
+    if (!hub) return this.jsonResponse(res, { error: "not_configured" }, 500);
+    const m = p.match(/^\/api\/admin\/shared-tasks\/([^/]+)\/detail$/);
+    if (!m) return this.jsonResponse(res, { error: "bad_request" }, 400);
+    const taskId = decodeURIComponent(m[1]);
+    try {
+      const data = await hubRequestJson(hub.hubUrl, hub.userToken, `/api/v1/hub/shared-tasks/${encodeURIComponent(taskId)}/detail`, { method: "GET" }) as any;
+      this.jsonResponse(res, data);
+    } catch (err) {
+      this.jsonResponse(res, { error: String(err) }, 500);
+    }
+  }
+
+  private async serveHubSkillDetail(res: http.ServerResponse, p: string): Promise<void> {
+    const hub = this.resolveHubConnection();
+    if (!hub) return this.jsonResponse(res, { error: "not_configured" }, 500);
+    const m = p.match(/^\/api\/admin\/shared-skills\/([^/]+)\/detail$/);
+    if (!m) return this.jsonResponse(res, { error: "bad_request" }, 400);
+    const skillId = decodeURIComponent(m[1]);
+    try {
+      const data = await hubRequestJson(hub.hubUrl, hub.userToken, `/api/v1/hub/shared-skills/${encodeURIComponent(skillId)}/detail`, { method: "GET" }) as any;
+      this.jsonResponse(res, data);
+    } catch (err) {
+      this.jsonResponse(res, { error: String(err) }, 500);
+    }
+  }
+
   private async serveAdminSharedSkills(res: http.ServerResponse): Promise<void> {
     const hub = this.resolveHubConnection();
     if (!hub) return this.jsonResponse(res, { skills: [], error: "not_configured" });
     try {
       const data = await hubRequestJson(hub.hubUrl, hub.userToken, "/api/v1/hub/admin/shared-skills", { method: "GET" }) as any;
-      this.jsonResponse(res, { skills: Array.isArray(data?.skills) ? data.skills : [] });
+      const skills = Array.isArray(data?.skills) ? data.skills : [];
+      for (const sk of skills) {
+        if (!sk.description && sk.sourceSkillId) {
+          const local = this.store.getSkill(sk.sourceSkillId);
+          if (local) { sk.description = sk.description || local.description; sk.name = sk.name || local.name; }
+        }
+      }
+      this.jsonResponse(res, { skills });
     } catch (err) {
       this.jsonResponse(res, { skills: [], error: String(err) });
     }
@@ -1846,7 +2354,14 @@ export class ViewerServer {
     if (!hub) return this.jsonResponse(res, { memories: [], error: "not_configured" });
     try {
       const data = await hubRequestJson(hub.hubUrl, hub.userToken, "/api/v1/hub/admin/shared-memories", { method: "GET" }) as any;
-      this.jsonResponse(res, { memories: Array.isArray(data?.memories) ? data.memories : [] });
+      const memories = Array.isArray(data?.memories) ? data.memories : [];
+      for (const m of memories) {
+        if (!m.content && m.sourceChunkId) {
+          const local = this.store.getChunk(m.sourceChunkId);
+          if (local) { m.content = local.content; if (!m.summary && local.summary) m.summary = local.summary; }
+        }
+      }
+      this.jsonResponse(res, { memories });
     } catch (err) {
       this.jsonResponse(res, { memories: [], error: String(err) });
     }
@@ -1864,7 +2379,121 @@ export class ViewerServer {
     }
   }
 
-  private serveLocalIPs(res: http.ServerResponse): void {
+  private async serveSharingNotifications(res: http.ServerResponse, url: URL): Promise<void> {
+    const hub = this.resolveHubConnection();
+    if (!hub) return this.jsonResponse(res, { notifications: [], unreadCount: 0 });
+    try {
+      const unread = url.searchParams.get("unread") === "1" ? "?unread=1" : "";
+      const data = await hubRequestJson(hub.hubUrl, hub.userToken, `/api/v1/hub/notifications${unread}`) as any;
+      this.jsonResponse(res, data);
+    } catch {
+      this.jsonResponse(res, { notifications: [], unreadCount: 0 });
+    }
+  }
+
+  private handleSharingNotificationsRead(req: http.IncomingMessage, res: http.ServerResponse): void {
+    const hub = this.resolveHubConnection();
+    if (!hub) return this.jsonResponse(res, { ok: false, error: "not_configured" });
+    this.readBody(req, async (raw) => {
+      try {
+        const body = JSON.parse(raw || "{}");
+        await hubRequestJson(hub.hubUrl, hub.userToken, "/api/v1/hub/notifications/read", { method: "POST", body: JSON.stringify(body) });
+        this.jsonResponse(res, { ok: true });
+        try {
+          const data = (await hubRequestJson(hub.hubUrl, hub.userToken, "/api/v1/hub/notifications?unread=1")) as any;
+          const count = data?.unreadCount ?? 0;
+          this.lastKnownNotifCount = count;
+          this.broadcastNotifSSE({ type: "update", unreadCount: count });
+        } catch { /* best effort */ }
+      } catch (err) {
+        this.jsonResponse(res, { ok: false, error: String(err) });
+      }
+    });
+  }
+
+  private handleSharingNotificationsClear(req: http.IncomingMessage, res: http.ServerResponse): void {
+    const hub = this.resolveHubConnection();
+    if (!hub) return this.jsonResponse(res, { ok: false, error: "not_configured" });
+    this.readBody(req, async () => {
+      try {
+        await hubRequestJson(hub.hubUrl, hub.userToken, "/api/v1/hub/notifications/clear", { method: "POST", body: "{}" });
+        this.jsonResponse(res, { ok: true });
+        this.broadcastNotifSSE({ type: "cleared", unreadCount: 0 });
+      } catch (err) {
+        this.jsonResponse(res, { ok: false, error: String(err) });
+      }
+    });
+  }
+
+  private handleNotifSSE(req: http.IncomingMessage, res: http.ServerResponse): void {
+    res.writeHead(200, {
+      "Content-Type": "text/event-stream",
+      "Cache-Control": "no-cache",
+      Connection: "keep-alive",
+      "Access-Control-Allow-Origin": "*",
+    });
+    res.write("data: {\"type\":\"connected\"}\n\n");
+    this.notifSSEClients.push(res);
+    if (!this.notifPollTimer) this.startNotifPoll();
+    req.on("close", () => {
+      this.notifSSEClients = this.notifSSEClients.filter((c) => c !== res);
+      if (this.notifSSEClients.length === 0) this.stopNotifPoll();
+    });
+  }
+
+  private broadcastNotifSSE(data: Record<string, unknown>): void {
+    const msg = `data: ${JSON.stringify(data)}\n\n`;
+    this.notifSSEClients = this.notifSSEClients.filter((c) => {
+      try { c.write(msg); return true; } catch { return false; }
+    });
+  }
+
+  private startNotifPoll(): void {
+    this.stopNotifPoll();
+    const tick = async () => {
+      const hub = this.resolveHubConnection();
+      if (!hub) return;
+      try {
+        const data = (await hubRequestJson(hub.hubUrl, hub.userToken, "/api/v1/hub/notifications?unread=1")) as any;
+        const count = data?.unreadCount ?? 0;
+        if (count !== this.lastKnownNotifCount) {
+          this.lastKnownNotifCount = count;
+          this.broadcastNotifSSE({ type: "update", unreadCount: count });
+        }
+      } catch { /* ignore */ }
+    };
+    tick();
+    this.notifPollTimer = setInterval(tick, 3000);
+  }
+
+  private stopNotifPoll(): void {
+    if (this.notifPollTimer) { clearInterval(this.notifPollTimer); this.notifPollTimer = undefined; }
+  }
+
+  private startHubHeartbeat(): void {
+    this.stopHubHeartbeat();
+    const sendHeartbeat = async () => {
+      try {
+        const hub = this.resolveHubConnection();
+        if (!hub) {
+          const persisted = this.store.getClientHubConnection();
+          if (persisted?.hubUrl && persisted?.userToken) {
+            await hubRequestJson(persisted.hubUrl, persisted.userToken, "/api/v1/hub/heartbeat", { method: "POST" });
+          }
+          return;
+        }
+        await hubRequestJson(hub.hubUrl, hub.userToken, "/api/v1/hub/heartbeat", { method: "POST" });
+      } catch { /* best-effort */ }
+    };
+    sendHeartbeat();
+    this.hubHeartbeatTimer = setInterval(sendHeartbeat, ViewerServer.HUB_HEARTBEAT_INTERVAL_MS);
+  }
+
+  private stopHubHeartbeat(): void {
+    if (this.hubHeartbeatTimer) { clearInterval(this.hubHeartbeatTimer); this.hubHeartbeatTimer = undefined; }
+  }
+
+  private getLocalIPs(): string[] {
     const nets = os.networkInterfaces();
     const ips: string[] = [];
     for (const name of Object.keys(nets)) {
@@ -1874,6 +2503,11 @@ export class ViewerServer {
         }
       }
     }
+    return ips;
+  }
+
+  private serveLocalIPs(res: http.ServerResponse): void {
+    const ips = this.getLocalIPs();
     res.writeHead(200, { "Content-Type": "application/json" });
     res.end(JSON.stringify({ ips }));
   }
@@ -1911,7 +2545,7 @@ export class ViewerServer {
   }
 
   private handleSaveConfig(req: http.IncomingMessage, res: http.ServerResponse): void {
-    this.readBody(req, (body) => {
+    this.readBody(req, async (body) => {
       try {
         const newCfg = JSON.parse(body);
         const cfgPath = this.getOpenClawConfigPath();
@@ -1934,6 +2568,11 @@ export class ViewerServer {
         if (!entry.config) entry.config = {};
         const config = entry.config as Record<string, unknown>;
 
+        const oldSharing = config.sharing as Record<string, unknown> | undefined;
+        const oldSharingRole = oldSharing?.role as string | undefined;
+        const oldSharingEnabled = Boolean(oldSharing?.enabled);
+        const oldClientHubAddress = String((oldSharing?.client as Record<string, unknown>)?.hubAddress || "");
+
         if (newCfg.embedding) config.embedding = newCfg.embedding;
         if (newCfg.summarizer) config.summarizer = newCfg.summarizer;
         if (newCfg.skillEvolution) config.skillEvolution = newCfg.skillEvolution;
@@ -1942,16 +2581,76 @@ export class ViewerServer {
         if (newCfg.sharing !== undefined) {
           const existing = (config.sharing as Record<string, unknown>) || {};
           const merged = { ...existing, ...newCfg.sharing };
-          // Deep-merge capabilities so new keys don't wipe existing ones
           if (newCfg.sharing.capabilities && existing.capabilities) {
             merged.capabilities = { ...(existing.capabilities as Record<string, unknown>), ...newCfg.sharing.capabilities };
           }
+          if (merged.role === "client" && merged.client) {
+            const clientCfg = merged.client as Record<string, unknown>;
+            const addr = String(clientCfg.hubAddress || "");
+            if (addr) {
+              const localIPs = this.getLocalIPs();
+              localIPs.push("127.0.0.1", "localhost", "0.0.0.0");
+              try {
+                const u = new URL(addr.startsWith("http") ? addr : `http://${addr}`);
+                if (localIPs.includes(u.hostname)) {
+                  res.writeHead(400, { "Content-Type": "application/json" });
+                  res.end(JSON.stringify({ error: "cannot_join_self" }));
+                  return;
+                }
+              } catch {}
+            }
+          }
+
+          const newRole = merged.role as string | undefined;
+          const newEnabled = Boolean(merged.enabled);
+
+          // Detect disabling sharing or switching away from hub mode
+          const wasHub = oldSharingEnabled && oldSharingRole === "hub";
+          const isHub = newEnabled && newRole === "hub";
+          if (wasHub && !isHub) {
+            await this.notifyHubShutdown();
+            this.stopHubHeartbeat();
+            this.log.info("Hub shutting down: notified connected clients");
+          }
+
+          // Detect disabling sharing or switching away from client mode
+          const wasClient = oldSharingEnabled && oldSharingRole === "client";
+          const isClient = newEnabled && newRole === "client";
+          if (wasClient && !isClient) {
+            this.notifyHubLeave();
+            this.store.clearClientHubConnection();
+            this.log.info("Cleared client hub connection (sharing disabled or role changed)");
+          }
+
+          // Detect switching to a different Hub while still in client mode
+          if (wasClient && isClient) {
+            const newClientAddr = String((merged.client as Record<string, unknown>)?.hubAddress || "");
+            if (newClientAddr && oldClientHubAddress && normalizeHubUrl(newClientAddr) !== normalizeHubUrl(oldClientHubAddress)) {
+              this.notifyHubLeave();
+              this.store.clearClientHubConnection();
+              this.log.info("Cleared client hub connection (switched to different Hub)");
+            }
+          }
+
+          if (merged.role === "hub") {
+            merged.client = { hubAddress: "", userToken: "", teamToken: "" };
+          } else if (merged.role === "client") {
+            merged.hub = { port: 18800, teamName: "", teamToken: "" };
+          }
           config.sharing = merged;
         }
 
         fs.mkdirSync(path.dirname(cfgPath), { recursive: true });
         fs.writeFileSync(cfgPath, JSON.stringify(raw, null, 2), "utf-8");
         this.log.info("Plugin config updated via Viewer");
+        this.stopHubHeartbeat();
+
+        // When switching to client mode, immediately send join request
+        const finalSharing = config.sharing as Record<string, unknown> | undefined;
+        if (finalSharing?.role === "client" && oldSharingRole !== "client") {
+          this.autoJoinOnSave(finalSharing).catch(e => this.log.warn(`Auto-join on save failed: ${e}`));
+        }
+
         this.jsonResponse(res, { ok: true });
       } catch (e) {
         this.log.warn(`handleSaveConfig error: ${e}`);
@@ -1961,6 +2660,87 @@ export class ViewerServer {
     });
   }
 
+  private async autoJoinOnSave(sharing: Record<string, unknown>): Promise<void> {
+    const clientCfg = sharing.client as Record<string, unknown> | undefined;
+    const hubAddress = String(clientCfg?.hubAddress || "");
+    const teamToken = String(clientCfg?.teamToken || "");
+    if (!hubAddress || !teamToken) return;
+    const hubUrl = normalizeHubUrl(hubAddress);
+    const os = await import("os");
+    const nickname = String(clientCfg?.nickname || "");
+    const username = nickname || os.userInfo().username || "user";
+    const hostname = os.hostname() || "unknown";
+    const result = await hubRequestJson(hubUrl, "", "/api/v1/hub/join", {
+      method: "POST",
+      body: JSON.stringify({ teamToken, username, deviceName: hostname }),
+    }) as any;
+    this.store.setClientHubConnection({
+      hubUrl,
+      userId: String(result.userId || ""),
+      username,
+      userToken: result.userToken || "",
+      role: "member",
+      connectedAt: Date.now(),
+    });
+    this.log.info(`Auto-join on save: status=${result.status}, userId=${result.userId}`);
+    if (result.userToken) {
+      this.startHubHeartbeat();
+    }
+  }
+
+  private async notifyHubLeave(): Promise<void> {
+    try {
+      const hub = this.resolveHubConnection();
+      if (hub) {
+        await hubRequestJson(hub.hubUrl, hub.userToken, "/api/v1/hub/leave", { method: "POST" });
+        this.log.info("Notified Hub of voluntary leave");
+        return;
+      }
+      const persisted = this.store.getClientHubConnection();
+      if (persisted?.hubUrl && persisted?.userToken) {
+        await hubRequestJson(persisted.hubUrl, persisted.userToken, "/api/v1/hub/leave", { method: "POST" });
+        this.log.info("Notified Hub of voluntary leave (persisted connection)");
+      }
+    } catch (e) {
+      this.log.warn(`Failed to notify Hub of leave: ${e}`);
+    }
+  }
+
+  private async notifyHubShutdown(): Promise<void> {
+    try {
+      const sharing = this.ctx?.config.sharing;
+      if (!sharing || sharing.role !== "hub") return;
+      const hubPort = sharing.hub?.port ?? 18800;
+      const authPath = path.join(this.dataDir, "hub-auth.json");
+      let adminToken: string | undefined;
+      try {
+        const authData = JSON.parse(fs.readFileSync(authPath, "utf8"));
+        adminToken = authData?.bootstrapAdminToken;
+      } catch { return; }
+      if (!adminToken) return;
+
+      const users = this.store.listHubUsers("active");
+      const { v4: uuidv4 } = require("uuid");
+      for (const u of users) {
+        try {
+          this.store.insertHubNotification({
+            id: uuidv4(),
+            userId: u.id,
+            type: "hub_shutdown",
+            resource: "hub",
+            title: "Hub is shutting down",
+            message: "The Hub server is shutting down. You may be disconnected.",
+          });
+        } catch (e) {
+          this.log.warn(`Failed to insert shutdown notification for user ${u.id}: ${e}`);
+        }
+      }
+      this.log.info(`Hub shutdown: notified ${users.length} approved user(s)`);
+    } catch (e) {
+      this.log.warn(`notifyHubShutdown error: ${e}`);
+    }
+  }
+
   private handleUpdateUsername(req: http.IncomingMessage, res: http.ServerResponse): void {
     this.readBody(req, async (body) => {
       if (!this.ctx) return this.jsonResponse(res, { error: "sharing_unavailable" });
@@ -2014,6 +2794,15 @@ export class ViewerServer {
       try {
         const { hubUrl } = JSON.parse(body);
         if (!hubUrl) { this.jsonResponse(res, { ok: false, error: "hubUrl is required" }); return; }
+        try {
+          const localIPs = this.getLocalIPs();
+          localIPs.push("127.0.0.1", "localhost", "0.0.0.0");
+          const parsed = new URL(hubUrl.startsWith("http") ? hubUrl : `http://${hubUrl}`);
+          if (localIPs.includes(parsed.hostname)) {
+            this.jsonResponse(res, { ok: false, error: "cannot_join_self" });
+            return;
+          }
+        } catch {}
         const url = hubUrl.replace(/\/+$/, "") + "/api/v1/hub/info";
         const ctrl = new AbortController();
         const timeout = setTimeout(() => ctrl.abort(), 8000);
@@ -2405,7 +3194,7 @@ export class ViewerServer {
 
   private getOpenClawHome(): string {
     const home = process.env.HOME || process.env.USERPROFILE || "";
-    return path.join(home, ".openclaw");
+    return process.env.OPENCLAW_STATE_DIR || path.join(home, ".openclaw");
   }
 
   private handleCleanupPolluted(res: http.ServerResponse): void {
@@ -2434,7 +3223,7 @@ export class ViewerServer {
     try {
       const ocHome = this.getOpenClawHome();
       const memoryDir = path.join(ocHome, "memory");
-      const sessionsDir = path.join(ocHome, "agents", "main", "sessions");
+      const agentsDir = path.join(ocHome, "agents");
 
       const sqliteFiles: Array<{ file: string; chunks: number }> = [];
       if (fs.existsSync(memoryDir)) {
@@ -2453,31 +3242,36 @@ export class ViewerServer {
 
       let sessionCount = 0;
       let messageCount = 0;
-      if (fs.existsSync(sessionsDir)) {
-        const jsonlFiles = fs.readdirSync(sessionsDir).filter(f => f.includes(".jsonl"));
-        sessionCount = jsonlFiles.length;
-        for (const f of jsonlFiles) {
-          try {
-            const content = fs.readFileSync(path.join(sessionsDir, f), "utf-8");
-            const lines = content.split("\n").filter(l => l.trim());
-            for (const line of lines) {
-              try {
-                const obj = JSON.parse(line);
-                if (obj.type === "message") {
-                  const role = obj.message?.role ?? obj.role;
-                  if (role === "user" || role === "assistant") {
-                    const mc = obj.message?.content ?? obj.content;
-                    let txt = "";
-                    if (typeof mc === "string") txt = mc;
-                    else if (Array.isArray(mc)) txt = mc.filter((p: any) => p.type === "text" && p.text).map((p: any) => p.text).join("\n");
-                    else txt = JSON.stringify(mc);
-                    if (role === "user") txt = stripInboundMetadata(txt);
-                    if (txt && txt.length >= 10) messageCount++;
+      if (fs.existsSync(agentsDir)) {
+        for (const entry of fs.readdirSync(agentsDir, { withFileTypes: true })) {
+          if (!entry.isDirectory()) continue;
+          const sessDir = path.join(agentsDir, entry.name, "sessions");
+          if (!fs.existsSync(sessDir)) continue;
+          const jsonlFiles = fs.readdirSync(sessDir).filter(f => f.includes(".jsonl"));
+          sessionCount += jsonlFiles.length;
+          for (const f of jsonlFiles) {
+            try {
+              const content = fs.readFileSync(path.join(sessDir, f), "utf-8");
+              const lines = content.split("\n").filter(l => l.trim());
+              for (const line of lines) {
+                try {
+                  const obj = JSON.parse(line);
+                  if (obj.type === "message") {
+                    const role = obj.message?.role ?? obj.role;
+                    if (role === "user" || role === "assistant") {
+                      const mc = obj.message?.content ?? obj.content;
+                      let txt = "";
+                      if (typeof mc === "string") txt = mc;
+                      else if (Array.isArray(mc)) txt = mc.filter((p: any) => p.type === "text" && p.text).map((p: any) => p.text).join("\n");
+                      else txt = JSON.stringify(mc);
+                      if (role === "user") txt = stripInboundMetadata(txt);
+                      if (txt && txt.length >= 10) messageCount++;
+                    }
                   }
-                }
-              } catch { /* skip bad lines */ }
-            }
-          } catch { /* skip unreadable */ }
+                } catch { /* skip bad lines */ }
+              }
+            } catch { /* skip unreadable */ }
+          }
         }
       }