openclaw-opincer 0.1.0

package/src/channel.ts

@@ -0,0 +1,868 @@
+/**
+ * channel.ts — Opincer channel plugin (WebSocket inbound, HTTP outbound)
+ * Adapted for Opincer protocol: REGISTER → AUTH → receive envelopes
+ *
+ * Key differences from openclaw-pincer:
+ * - WS URL: /api/v1/agents/{agent_id}/ws  (not /ws?agent_id=)
+ * - Groups API: /api/v1/agents/{id}/groups (not /api/v1/projects)
+ * - Room WS: /api/v1/rooms/{room_id}/ws?api_key=  (same)
+ *
+ * Context compression:
+ * - Fetches recent room messages and attaches them as context
+ * - When unsummarized message count >= SUMMARY_THRESHOLD, triggers AI summarization
+ * - Summaries stored in ~/.openclaw/opincer-summaries/{room_id}.json
+ * - Each dispatch: inject summary (if any) + last CONTEXT_MSG_COUNT raw messages
+ */
+
+import WebSocket from "ws";
+import { randomUUID } from "crypto";
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+
+// ── Context compression settings ────────────────────────────────────────────
+/** Number of recent raw messages to attach as context per dispatch */
+const CONTEXT_MSG_COUNT = 10;
+/** Trigger AI summarization when unsummarized messages reach this count */
+const SUMMARY_THRESHOLD = 30;
+/** Directory where per-room summary state is persisted */
+const SUMMARY_DIR = join(homedir(), ".openclaw", "opincer-summaries");
+
+interface RoomSummaryState {
+  roomId: string;
+  summary: string;           // latest summary text
+  summarizedUpTo: string;    // message ID (or ISO timestamp) up to which we've summarized
+  summarizedCount: number;   // how many messages are covered by the summary
+  updatedAt: string;
+}
+
+function getSummaryPath(roomId: string): string {
+  return join(SUMMARY_DIR, `${roomId}.json`);
+}
+
+function loadSummary(roomId: string): RoomSummaryState | null {
+  try {
+    const raw = readFileSync(getSummaryPath(roomId), "utf-8");
+    return JSON.parse(raw) as RoomSummaryState;
+  } catch {
+    return null;
+  }
+}
+
+function saveSummary(state: RoomSummaryState): void {
+  try {
+    if (!existsSync(SUMMARY_DIR)) mkdirSync(SUMMARY_DIR, { recursive: true });
+    writeFileSync(getSummaryPath(state.roomId), JSON.stringify(state, null, 2), "utf-8");
+  } catch (e) {
+    console.error("[openclaw-opincer] Failed to save summary:", e);
+  }
+}
+
+/** Fetch recent messages from a room via REST API */
+async function fetchRecentMessages(
+  config: OpincerConfig,
+  roomId: string,
+  limit = 50,
+): Promise<Array<{ id: string; sender_name?: string; sender_agent_id?: string; content: string; created_at: string }>> {
+  try {
+    const url = `${config.baseUrl.replace(/\/$/, "")}/api/v1/rooms/${roomId}/messages?limit=${limit}`;
+    const res = await fetch(url, {
+      headers: { "X-API-Key": config.token },
+    });
+    if (!res.ok) return [];
+    const data = await res.json();
+    const msgs = Array.isArray(data) ? data : (data.messages ?? data.data ?? []);
+    return msgs;
+  } catch {
+    return [];
+  }
+}
+
+/** Format messages into a readable transcript for summarization */
+function formatTranscript(
+  messages: Array<{ sender_name?: string; sender_agent_id?: string; content: string; created_at: string }>,
+): string {
+  return messages.map(m => {
+    const who = m.sender_name ?? m.sender_agent_id?.slice(0, 8) ?? "?";
+    const ts = m.created_at ? new Date(m.created_at).toISOString().slice(11, 16) : "";
+    return `[${ts}] ${who}: ${m.content}`;
+  }).join("\n");
+}
+
+/**
+ * Generate an AI summary via:
+ * 1. Opincer backend POST /rooms/{id}/summary (if available)
+ * 2. OpenAI-compatible LLM API (config.summaryApiBase / summaryApiKey)
+ * 3. Local structured compression fallback
+ */
+async function generateSummary(
+  config: OpincerConfig,
+  roomId: string,
+  messages: Array<{ sender_name?: string; sender_agent_id?: string; content: string; created_at: string }>,
+): Promise<string> {
+  // 1. Try Opincer backend summary API
+  try {
+    const url = `${config.baseUrl.replace(/\/$/, "")}/api/v1/rooms/${roomId}/summary`;
+    const res = await fetch(url, {
+      method: "POST",
+      headers: { "X-API-Key": config.token, "Content-Type": "application/json" },
+      body: JSON.stringify({ messages }),
+    });
+    if (res.ok) {
+      const data = await res.json();
+      const s = data.summary ?? data.content ?? "";
+      if (s) return s;
+    }
+  } catch { /* fall through */ }
+
+  // 2. Try OpenAI-compatible LLM (LiteLLM proxy or any compatible endpoint)
+  const apiBase = config.summaryApiBase;
+  const apiKey = config.summaryApiKey;
+  if (apiBase && apiKey) {
+    try {
+      const transcript = formatTranscript(messages);
+      const prompt = [
+        "以下是一个群聊的历史消息记录。请用简洁的中文总结关键信息：",
+        "- 讨论了哪些主题/任务",
+        "- 做了哪些决定",
+        "- 有哪些待办项",
+        "- 重要的人名/任务名/版本号",
+        "保持简洁（200字以内），不要逐条复述每条消息。",
+        "",
+        "消息记录：",
+        transcript,
+      ].join("\n");
+
+      const model = config.summaryModel ?? "gpt-4o-mini";
+      const res = await fetch(`${apiBase.replace(/\/$/, "")}/chat/completions`, {
+        method: "POST",
+        headers: {
+          "Authorization": `Bearer ${apiKey}`,
+          "Content-Type": "application/json",
+        },
+        body: JSON.stringify({
+          model,
+          messages: [{ role: "user", content: prompt }],
+          max_tokens: 400,
+          temperature: 0.3,
+        }),
+      });
+
+      if (res.ok) {
+        const data = await res.json();
+        const text: string = data.choices?.[0]?.message?.content ?? "";
+        if (text) {
+          console.log(`[openclaw-opincer] ✨ AI summary generated (${text.length} chars)`);
+          return `[AI摘要 — 涵盖 ${messages.length} 条消息]\n${text}`;
+        }
+      } else {
+        const errText = await res.text().catch(() => "");
+        console.warn(`[openclaw-opincer] LLM summary API error ${res.status}: ${errText.slice(0, 100)}`);
+      }
+    } catch (e) {
+      console.warn("[openclaw-opincer] LLM summary failed:", e);
+    }
+  }
+
+  // 3. Local structured compression fallback
+  const lines = messages.map(m => {
+    const who = m.sender_name ?? m.sender_agent_id?.slice(0, 8) ?? "?";
+    const ts = m.created_at ? new Date(m.created_at).toISOString().slice(11, 16) : "";
+    const text = m.content.length > 120 ? m.content.slice(0, 120) + "…" : m.content;
+    return `[${ts}] ${who}: ${text}`;
+  });
+  return `[历史消息摘要 — ${messages.length} 条，未配置 AI]\n` + lines.join("\n");
+}
+
+export interface OpincerConfig {
+  baseUrl: string;
+  token: string;           // api_key
+  agentId: string;         // registered agent UUID on Opincer
+  agentName: string;       // display name
+  /** OpenAI-compatible API base URL for AI summarization (e.g. LiteLLM proxy) */
+  summaryApiBase?: string;
+  /** API key for the summary LLM endpoint */
+  summaryApiKey?: string;
+  /** Model to use for summarization (default: gpt-4o-mini or any available) */
+  summaryModel?: string;
+}
+
+function resolveConfig(cfg: any): OpincerConfig {
+  return (cfg?.channels?.["openclaw-opincer"] ?? {}) as OpincerConfig;
+}
+
+function wsUrl(config: OpincerConfig): string {
+  const base = config.baseUrl.replace(/\/$/, "").replace(/^http/, "ws");
+  return `${base}/api/v1/agents/${config.agentId}/ws`;
+}
+
+function makeEnvelope(type: string, from: string, to: string, payload: any): string {
+  return JSON.stringify({
+    id: randomUUID(),
+    type,
+    from,
+    to,
+    ts: new Date().toISOString(),
+    payload,
+  });
+}
+
+async function httpPost(config: OpincerConfig, path: string, body: any): Promise<void> {
+  const url = `${config.baseUrl.replace(/\/$/, "")}/api/v1${path}`;
+  const res = await fetch(url, {
+    method: "POST",
+    headers: { "X-API-Key": config.token, "Content-Type": "application/json" },
+    body: JSON.stringify(body),
+  });
+  if (!res.ok) throw new Error(`Opincer POST ${path} ${res.status}`);
+}
+
+// Fetch groups that this agent belongs to (via /api/v1/agents/{id}/groups)
+async function fetchAgentGroups(config: OpincerConfig): Promise<string[]> {
+  const url = `${config.baseUrl.replace(/\/$/, "")}/api/v1/agents/${config.agentId}/groups`;
+  try {
+    const res = await fetch(url, {
+      headers: { "X-API-Key": config.token, "User-Agent": "openclaw-opincer/0.1" },
+    });
+    if (!res.ok) return [];
+    const data = await res.json();
+    const groups = Array.isArray(data) ? data : [];
+    // Each group has a room_id or id field
+    return groups.map((g: any) => g.room_id ?? g.id).filter(Boolean);
+  } catch {
+    return [];
+  }
+}
+
+// Subscribe to a single room WebSocket and dispatch messages
+function connectRoomWs(params: {
+  config: OpincerConfig;
+  ctx: any;
+  roomId: string;
+  signal: AbortSignal;
+}): void {
+  const { config, ctx, roomId, signal } = params;
+  let retryMs = 2000;
+
+  function connect() {
+    if (signal.aborted) return;
+    const wsBase = config.baseUrl.replace(/\/$/, "").replace(/^http/, "ws");
+    const ws = new WebSocket(`${wsBase}/api/v1/rooms/${roomId}/ws?api_key=${config.token}`);
+
+    ws.on("open", () => {
+      retryMs = 2000;
+      console.log(`[openclaw-opincer] Room WS connected: ${roomId}`);
+    });
+
+    ws.on("message", (data: WebSocket.Data) => {
+      try {
+        const msg = JSON.parse(data.toString());
+        if (msg.type !== "room.message") return;
+        const payload = msg.data ?? msg.payload ?? {};
+        const sender = payload.sender_agent_id ?? "unknown";
+        const content = payload.content ?? "";
+        if (sender === config.agentId || !content) return;
+        // Mention-only: respond only when @agentName or @all
+        const agentName = config.agentName ?? "";
+        const isMentioned = agentName && content.includes(`@${agentName}`);
+        const isBroadcast = content.includes("@all") || content.includes("@所有人");
+        if (!isMentioned && !isBroadcast) return;
+        const runtime = ctx.channelRuntime;
+        if (!runtime) return;
+        dispatchToAgent(config, ctx, runtime, sender, content, roomId);
+      } catch { /* ignore */ }
+    });
+
+    ws.on("close", () => {
+      if (signal.aborted) return;
+      setTimeout(connect, retryMs);
+      retryMs = Math.min(retryMs * 1.5, 30000);
+    });
+
+    ws.on("error", () => ws.close());
+    signal.addEventListener("abort", () => ws.close(), { once: true });
+  }
+
+  connect();
+}
+
+// Subscribe to all agent groups, refresh every GROUP_REFRESH_INTERVAL ms
+function startGroupSubscriptions(params: {
+  config: OpincerConfig;
+  ctx: any;
+  signal: AbortSignal;
+}): void {
+  const { config, ctx, signal } = params;
+  const GROUP_REFRESH_MS = 60_000;
+  const subscribedRooms = new Set<string>();
+
+  async function refresh() {
+    if (signal.aborted) return;
+    const rooms = await fetchAgentGroups(config);
+    for (const roomId of rooms) {
+      if (!subscribedRooms.has(roomId)) {
+        subscribedRooms.add(roomId);
+        connectRoomWs({ config, ctx, roomId, signal });
+        console.log(`[openclaw-opincer] Subscribed to group room: ${roomId}`);
+      }
+    }
+  }
+
+  refresh();
+  const timer = setInterval(refresh, GROUP_REFRESH_MS);
+  signal.addEventListener("abort", () => clearInterval(timer), { once: true });
+}
+
+function connectWs(params: {
+  config: OpincerConfig;
+  ctx: any;
+  signal: AbortSignal;
+}) {
+  const { config, ctx, signal } = params;
+  let retryMs = 1000;
+  let heartbeatTimer: ReturnType<typeof setInterval> | null = null;
+
+  function connect() {
+    if (signal.aborted) return;
+
+    const ws = new WebSocket(wsUrl(config));
+
+    ws.on("open", () => {
+      retryMs = 1000;
+      console.log("[openclaw-opincer] WebSocket connected, sending REGISTER + AUTH");
+
+      // Opincer handshake: REGISTER then AUTH
+      ws.send(makeEnvelope("REGISTER", config.agentId, "hub", {
+        name: config.agentName,
+        capabilities: [],
+        runtime_version: "openclaw/openclaw-opincer/0.1",
+        messaging_mode: "ws",
+      }));
+      ws.send(makeEnvelope("AUTH", config.agentId, "hub", {
+        api_key: config.token,
+      }));
+
+      // Heartbeat every 30s
+      if (heartbeatTimer) clearInterval(heartbeatTimer);
+      heartbeatTimer = setInterval(() => {
+        if (ws.readyState === WebSocket.OPEN) {
+          ws.send(makeEnvelope("HEARTBEAT", config.agentId, "hub", {
+            agent_id: config.agentId,
+          }));
+        }
+      }, 30000);
+    });
+
+    ws.on("message", (data: WebSocket.Data) => {
+      try {
+        const msg = JSON.parse(data.toString());
+        handleMessage(config, ctx, msg);
+      } catch {}
+    });
+
+    ws.on("close", () => {
+      if (heartbeatTimer) { clearInterval(heartbeatTimer); heartbeatTimer = null; }
+      if (signal.aborted) return;
+      console.log(`[openclaw-opincer] WS closed, reconnecting in ${retryMs}ms`);
+      setTimeout(connect, retryMs);
+      retryMs = Math.min(retryMs * 2, 30000);
+    });
+
+    ws.on("error", (err: Error) => {
+      if (!signal.aborted) console.error("[openclaw-opincer] WS error:", err.message);
+      ws.close();
+    });
+
+    signal.addEventListener("abort", () => {
+      if (heartbeatTimer) { clearInterval(heartbeatTimer); heartbeatTimer = null; }
+      ws.close();
+    }, { once: true });
+  }
+
+  connect();
+}
+
+function handleMessage(config: OpincerConfig, ctx: any, msg: any) {
+  const runtime = ctx.channelRuntime;
+  if (!runtime) return;
+
+  const msgType = msg.type ?? "";
+  const payload = msg.payload ?? {};
+  const fromId = msg.from ?? "unknown";
+
+  // ACK
+  if (msgType === "ACK") {
+    if (payload.status === "ok") {
+      console.log("[openclaw-opincer] ✓ Authenticated with Opincer hub");
+    } else {
+      console.error("[openclaw-opincer] AUTH failed:", payload.error);
+    }
+    return;
+  }
+
+  // HEARTBEAT_ACK — check for inbox
+  if (msgType === "HEARTBEAT_ACK" || msgType === "heartbeat.ack") {
+    const inbox = payload.inbox ?? [];
+    for (const item of inbox) {
+      const inner = item.payload ?? {};
+      const text = inner.text ?? JSON.stringify(inner);
+      const sender = item.from ?? "unknown";
+      dispatchToAgent(config, ctx, runtime, sender, text, undefined);
+    }
+    return;
+  }
+
+  // Ignore messages from self
+  if (fromId === config.agentId) return;
+
+  // PING → we just keep WS alive via heartbeat
+  if (msgType === "PING") return;
+
+  // DM message
+  if (msgType === "MESSAGE" || msgType === "agent.message") {
+    const text = payload.text ?? "";
+    if (!text) return;
+    console.log(`[openclaw-opincer] 💬 DM from ${fromId.slice(0, 8)}: ${text.slice(0, 60)}`);
+    dispatchToAgent(config, ctx, runtime, fromId, text, undefined);
+    return;
+  }
+
+  // Inbox delivery (reconnect catch-up)
+  if (msgType === "inbox.delivery") {
+    const items = Array.isArray(payload) ? payload : [payload];
+    for (const item of items) {
+      const inner = item.payload ?? {};
+      const text = inner.text ?? JSON.stringify(inner);
+      const sender = item.from ?? "unknown";
+      console.log(`[openclaw-opincer] 📬 Inbox from ${sender.slice(0, 8)}`);
+      dispatchToAgent(config, ctx, runtime, sender, text, undefined);
+    }
+    return;
+  }
+
+  // Room message
+  if (msgType === "room.message") {
+    const data = msg.data ?? msg.payload ?? {};
+    const sender = data.sender_agent_id ?? "unknown";
+    const content = data.content ?? "";
+    const roomId = data.room_id ?? msg.room_id ?? "";
+    if (sender === config.agentId || !content) return;
+    const agentName = config.agentName ?? "";
+    const isMentioned = agentName && content.includes(`@${agentName}`);
+    const isBroadcast = content.includes("@all") || content.includes("@所有人");
+    if (!isMentioned && !isBroadcast) return;
+    console.log(`[openclaw-opincer] 💬 Room msg from ${sender.slice(0, 8)}: ${content.slice(0, 60)}`);
+    dispatchToAgent(config, ctx, runtime, sender, content, roomId);
+    return;
+  }
+
+  // TASK_ASSIGN — notify project room + dispatch to agent
+  if (msgType === "TASK_ASSIGN" || msgType === "task.assigned") {
+    const taskId = payload.task_id ?? "?";
+    const title = payload.title ?? "";
+    const description = payload.description ?? "";
+    const assignedTo = payload.assigned_to ?? payload.assigned_agent_name ?? config.agentName;
+    const projectId = payload.project_id ?? "";
+
+    // Notify project room if we know the project
+    if (projectId) {
+      notifyProjectRoom(config, projectId, taskId, title, assignedTo).catch(() => {});
+    }
+
+    const text = `[Opincer Task]\ntask_id: ${taskId}\ntitle: ${title}\ndescription:\n${description}`;
+    console.log(`[openclaw-opincer] 📋 Task assigned: ${taskId.slice(0, 8)} ${title}`);
+    dispatchToAgent(config, ctx, runtime, fromId, text, undefined);
+    return;
+  }
+
+  // BROADCAST
+  if (msgType === "BROADCAST" || msgType === "broadcast") {
+    console.log(`[openclaw-opincer] 📢 Broadcast received`);
+    return;
+  }
+}
+
+// ── Task assignment room notification ────────────────────────────────────────
+
+/** Post a notification to the project room when a task is assigned */
+async function notifyProjectRoom(
+  config: OpincerConfig,
+  projectId: string,
+  taskId: string,
+  taskTitle: string,
+  assigneeName: string,
+): Promise<void> {
+  try {
+    // Fetch project to get room_id
+    const url = `${config.baseUrl.replace(/\/$/, "")}/api/v1/projects/${projectId}`;
+    const res = await fetch(url, { headers: { "X-API-Key": config.token } });
+    if (!res.ok) return;
+    const project: { room_id?: string; name?: string } = await res.json();
+    const roomId = project.room_id;
+    if (!roomId) return;
+
+    const msg = `📋 任务已分配\n任务：${taskTitle}\n分配给：${assigneeName}\ntask_id: ${taskId}`;
+    await httpPost(config, `/rooms/${roomId}/messages`, {
+      sender_agent_id: config.agentId,
+      content: msg,
+    });
+    console.log(`[openclaw-opincer] 🔔 Task assignment notified in room ${roomId.slice(0, 8)}`);
+  } catch (e) {
+    console.warn("[openclaw-opincer] Failed to notify project room:", e);
+  }
+}
+
+// ── Project context helpers ───────────────────────────────────────────────
+
+interface ProjectInfo {
+  id: string;
+  name: string;
+  room_id?: string;
+}
+
+interface AgentInfo {
+  id: string;
+  name: string;
+  status?: string;   // online / offline / busy
+}
+
+interface TaskSummary {
+  pending: number;
+  assigned: number;
+  running: number;
+  review: number;
+}
+
+// Cache room_id → ProjectInfo to avoid fetching full project list on every message
+const roomProjectCache = new Map<string, { project: ProjectInfo | null; expiresAt: number }>();
+const ROOM_PROJECT_CACHE_TTL_MS = 5 * 60 * 1000; // 5 minutes
+
+/** Find the project that owns this room (if any), with caching */
+async function fetchRoomProject(config: OpincerConfig, roomId: string): Promise<ProjectInfo | null> {
+  const cached = roomProjectCache.get(roomId);
+  if (cached && cached.expiresAt > Date.now()) {
+    return cached.project;
+  }
+  try {
+    const url = `${config.baseUrl.replace(/\/$/, "")}/api/v1/projects`;
+    const res = await fetch(url, { headers: { "X-API-Key": config.token } });
+    if (!res.ok) return null;
+    const data = await res.json();
+    const projects: ProjectInfo[] = Array.isArray(data) ? data : (data.projects ?? data.data ?? []);
+    const project = projects.find(p => p.room_id === roomId) ?? null;
+    // Cache result (including null = "no project for this room")
+    roomProjectCache.set(roomId, { project, expiresAt: Date.now() + ROOM_PROJECT_CACHE_TTL_MS });
+    return project;
+  } catch {
+    return null;
+  }
+}
+
+/** Get task count summary for a project */
+async function fetchProjectTaskSummary(config: OpincerConfig, projectId: string): Promise<TaskSummary | null> {
+  try {
+    const url = `${config.baseUrl.replace(/\/$/, "")}/api/v1/projects/${projectId}/tasks`;
+    const res = await fetch(url, { headers: { "X-API-Key": config.token } });
+    if (!res.ok) return null;
+    const data = await res.json();
+    const tasks: Array<{ status: string }> = Array.isArray(data) ? data : (data.tasks ?? data.data ?? []);
+    const summary: TaskSummary = { pending: 0, assigned: 0, running: 0, review: 0 };
+    for (const t of tasks) {
+      if (t.status === "pending") summary.pending++;
+      else if (t.status === "assigned") summary.assigned++;
+      else if (t.status === "running") summary.running++;
+      else if (t.status === "review") summary.review++;
+    }
+    return summary;
+  } catch {
+    return null;
+  }
+}
+
+/** Get room members with their online status */
+async function fetchRoomMembersWithStatus(config: OpincerConfig, roomId: string): Promise<AgentInfo[]> {
+  try {
+    const url = `${config.baseUrl.replace(/\/$/, "")}/api/v1/rooms/${roomId}/members`;
+    const res = await fetch(url, { headers: { "X-API-Key": config.token } });
+    if (!res.ok) return [];
+    const data = await res.json();
+    const members: any[] = Array.isArray(data) ? data : (data.members ?? data.data ?? []);
+    return members.map((m: any) => ({
+      id: m.agent_id ?? m.id ?? "",
+      name: m.name ?? m.agent_name ?? m.display_name ?? m.id?.slice(0, 8) ?? "?",
+      status: m.status ?? m.online_status ?? "offline",
+    })).filter(m => m.id && m.id !== config.agentId);
+  } catch {
+    return [];
+  }
+}
+
+/** Build dynamic project context header */
+async function buildProjectHeader(config: OpincerConfig, roomId: string): Promise<string> {
+  const [project, members] = await Promise.all([
+    fetchRoomProject(config, roomId),
+    fetchRoomMembersWithStatus(config, roomId),
+  ]);
+
+  const lines: string[] = [];
+
+  if (project) {
+    lines.push(`project_id: ${project.id}`);
+    lines.push(`project_name: ${project.name}`);
+
+    // Fetch task summary for this project
+    const taskSummary = await fetchProjectTaskSummary(config, project.id);
+    if (taskSummary) {
+      const taskParts: string[] = [];
+      if (taskSummary.pending > 0) taskParts.push(`${taskSummary.pending} pending`);
+      if (taskSummary.assigned > 0) taskParts.push(`${taskSummary.assigned} assigned`);
+      if (taskSummary.running > 0) taskParts.push(`${taskSummary.running} running`);
+      if (taskSummary.review > 0) taskParts.push(`${taskSummary.review} in review`);
+      if (taskParts.length > 0) {
+        lines.push(`tasks: ${taskParts.join(", ")}`);
+      } else {
+        lines.push(`tasks: none active`);
+      }
+    }
+  }
+
+  if (members.length > 0) {
+    const onlineMembers = members.filter(m => m.status === "online" || m.status === "busy");
+    const offlineMembers = members.filter(m => m.status !== "online" && m.status !== "busy");
+    if (onlineMembers.length > 0) {
+      lines.push(`online members: ${onlineMembers.map(m => `${m.name}(${m.id.slice(0, 8)})`).join(", ")}`);
+    }
+    if (offlineMembers.length > 0) {
+      lines.push(`offline members: ${offlineMembers.map(m => m.name).join(", ")}`);
+    }
+  }
+
+  if (lines.length === 0) return "";
+  return `[Opincer Room info]\nroom_id: ${roomId}\n${lines.join("\n")}`;
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+
+async function buildRoomContext(
+  config: OpincerConfig,
+  roomId: string,
+): Promise<string> {
+  // Run message fetch and project header in parallel
+  const [allMsgsNewestFirst, projectHeader] = await Promise.all([
+    fetchRecentMessages(config, roomId, Math.max(SUMMARY_THRESHOLD + CONTEXT_MSG_COUNT, 60)),
+    buildProjectHeader(config, roomId),
+  ]);
+
+  const parts: string[] = [];
+
+  // Inject project/member context header
+  if (projectHeader) {
+    parts.push(projectHeader);
+  }
+
+  if (allMsgsNewestFirst.length === 0) return parts.join("\n\n");
+
+  // API returns newest-first; reverse for chronological order
+  const allMsgs = [...allMsgsNewestFirst].reverse();
+
+  const state = loadSummary(roomId);
+  const summarizedUpToId = state?.summarizedUpTo ?? "";
+
+  // Find index of last summarized message
+  let summarizedIdx = -1;
+  if (summarizedUpToId) {
+    summarizedIdx = allMsgs.findIndex(m => m.id === summarizedUpToId);
+  }
+
+  // Messages after the summarized boundary
+  const unsummarizedMsgs = summarizedIdx >= 0
+    ? allMsgs.slice(summarizedIdx + 1)
+    : allMsgs;
+
+  // Trigger summarization if unsummarized count hits threshold
+  if (unsummarizedMsgs.length >= SUMMARY_THRESHOLD) {
+    // Summarize everything except the most recent CONTEXT_MSG_COUNT messages
+    const toSummarize = unsummarizedMsgs.slice(0, unsummarizedMsgs.length - CONTEXT_MSG_COUNT);
+    if (toSummarize.length > 0) {
+      console.log(`[openclaw-opincer] 📝 Generating summary for room ${roomId.slice(0, 8)} (${toSummarize.length} msgs)`);
+      try {
+        // For AI summary, present in chronological order
+        const existingSummary = state?.summary ?? "";
+        const combinedForSummary = existingSummary
+          ? [{ id: "", sender_name: "摘要", sender_agent_id: undefined, content: existingSummary, created_at: "" }, ...toSummarize]
+          : toSummarize;
+        const newSummaryText = await generateSummary(config, roomId, combinedForSummary);
+        const newState: RoomSummaryState = {
+          roomId,
+          summary: newSummaryText,
+          summarizedUpTo: toSummarize[toSummarize.length - 1]?.id ?? "",
+          summarizedCount: (state?.summarizedCount ?? 0) + toSummarize.length,
+          updatedAt: new Date().toISOString(),
+        };
+        saveSummary(newState);
+        console.log(`[openclaw-opincer] ✅ Summary saved for room ${roomId.slice(0, 8)}`);
+      } catch (e) {
+        console.error("[openclaw-opincer] Summary generation failed:", e);
+      }
+    }
+  }
+
+  // Build context block to inject
+  const freshState = loadSummary(roomId);
+  // Show most recent CONTEXT_MSG_COUNT messages in chronological order
+  const recentMsgs = allMsgs.slice(-CONTEXT_MSG_COUNT);
+
+  if (freshState?.summary) {
+    parts.push(`[Opincer Room context (summary of earlier messages)]\n${freshState.summary}`);
+  }
+
+  if (recentMsgs.length > 0) {
+    const recent = recentMsgs.map(m => {
+      const who = m.sender_name ?? m.sender_agent_id?.slice(0, 8) ?? "?";
+      return `[${who}]: ${m.content}`;
+    }).join("\n");
+    parts.push(`[Pincer Room context (last ${recentMsgs.length} msgs)]\n${recent}`);
+  }
+
+  return parts.join("\n\n");
+}
+
+function dispatchToAgent(
+  config: OpincerConfig, ctx: any, runtime: any,
+  senderId: string, text: string, roomId: string | undefined,
+) {
+  const peer = roomId
+    ? { kind: "group" as const, id: roomId }
+    : { kind: "direct" as const, id: senderId };
+
+  const route = runtime.routing.resolveAgentRoute({
+    cfg: ctx.cfg,
+    channel: "openclaw-opincer",
+    accountId: ctx.accountId,
+    peer,
+  });
+
+  // Build enriched body: inject room context for group messages
+  const buildAndDispatch = async () => {
+    let bodyForAgent = text;
+
+    if (roomId) {
+      try {
+        const roomCtx = await buildRoomContext(config, roomId);
+        if (roomCtx) {
+          bodyForAgent = `${roomCtx}\n\n[Pincer Room msg from ${senderId}]\n${text}`;
+        }
+      } catch (e) {
+        console.warn("[openclaw-opincer] Context build failed:", e);
+      }
+    }
+
+    runtime.reply.dispatchReplyWithBufferedBlockDispatcher({
+      ctx: {
+        Body: text,
+        BodyForAgent: bodyForAgent,
+        From: senderId,
+        SessionKey: route.sessionKey,
+        Channel: "openclaw-opincer",
+        AccountId: ctx.accountId,
+      },
+      cfg: ctx.cfg,
+      dispatcherOptions: {
+        deliver: async (payload: any) => {
+          try {
+            const replyText = payload.text ?? payload.content ?? JSON.stringify(payload);
+            console.log(`[openclaw-opincer] 📤 Delivering reply: ${replyText.slice(0, 60)}`);
+            if (roomId) {
+              await httpPost(config, `/rooms/${roomId}/messages`, {
+                sender_agent_id: config.agentId,
+                content: replyText,
+              });
+            } else {
+              await httpPost(config, "/messages/send", {
+                from_agent_id: config.agentId,
+                to_agent_id: senderId,
+                payload: { text: replyText },
+              });
+            }
+            console.log(`[openclaw-opincer] ✅ Reply sent`);
+          } catch (err: any) {
+            console.error(`[openclaw-opincer] ❌ Reply failed:`, err.message);
+          }
+        },
+      },
+    });
+  };
+
+  buildAndDispatch().catch(e => console.error("[openclaw-opincer] dispatchToAgent error:", e));
+}
+
+export const opincerChannel = {
+  id: "openclaw-opincer",
+  meta: {
+    id: "openclaw-opincer",
+    label: "Opincer",
+    selectionLabel: "Opincer (agent hub)",
+    docsPath: "/channels/opincer",
+    docsLabel: "opincer",
+    blurb: "Opincer agent hub — WebSocket connection.",
+    order: 81,
+  },
+  capabilities: {
+    chatTypes: ["direct", "group"],
+    media: false,
+    reactions: false,
+    threads: false,
+  },
+  config: {
+    listAccountIds: (cfg: any) => {
+      const c = resolveConfig(cfg);
+      return c.baseUrl && c.token && c.agentId ? ["default"] : [];
+    },
+    resolveAccount: (_cfg: any, accountId: string) => ({ accountId }),
+  },
+  gateway: {
+    startAccount: async (ctx: any) => {
+      const config = resolveConfig(ctx.cfg);
+      if (!config.baseUrl || !config.token || !config.agentId) {
+        console.warn("[openclaw-opincer] Missing baseUrl, token, or agentId. Channel not started.");
+        return;
+      }
+      if (!config.agentName) config.agentName = "openclaw-agent";
+
+      const signal: AbortSignal = ctx.abortSignal;
+
+      // Connect to agent DM hub (WebSocket)
+      connectWs({ config, ctx, signal });
+
+      // Subscribe to all agent groups (and refresh every 60s for new groups)
+      startGroupSubscriptions({ config, ctx, signal });
+
+      console.log("[openclaw-opincer] Started, connecting via WebSocket");
+
+      await new Promise<void>((resolve) => {
+        if (signal.aborted) return resolve();
+        signal.addEventListener("abort", () => resolve(), { once: true });
+      });
+    },
+  },
+  outbound: {
+    deliveryMode: "direct",
+    sendText: async (ctx: any) => {
+      const config = resolveConfig(ctx.cfg);
+      const to: string = ctx.to ?? "";
+      if (to.startsWith("room:")) {
+        await httpPost(config, `/rooms/${to.slice(5)}/messages`, {
+          sender_agent_id: config.agentId,
+          content: ctx.text,
+        });
+      } else {
+        await httpPost(config, "/messages/send", {
+          from_agent_id: config.agentId,
+          to_agent_id: to,
+          payload: { text: ctx.text },
+        });
+      }
+      return { ok: true };
+    },
+  },
+};