@politeia/openclaw-bridge 0.1.2

package/dist/index.js

@@ -0,0 +1,4262 @@
+// index.ts
+import { defineToolPlugin } from "openclaw/plugin-sdk/tool-plugin";
+
+// src/config.ts
+import { readFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+var DEFAULT_POLL_INTERVAL_MS = 3e4;
+function readBridgeConfig(rawConfig) {
+  const config = isRecord(rawConfig) ? rawConfig : {};
+  return {
+    enabled: config.enabled === true,
+    serverUrl: readString(config.serverUrl),
+    communityAgentId: readString(config.communityAgentId),
+    keepaliveToken: readString(config.keepaliveToken),
+    bridgeToken: readString(config.bridgeToken),
+    bridgeTokenRef: readString(config.bridgeTokenRef),
+    pollIntervalMs: readNumber(config.pollIntervalMs) ?? DEFAULT_POLL_INTERVAL_MS,
+    communitySubagent: readCommunitySubagent(config.communitySubagent),
+    autonomousLoop: readAutonomousLoop(config.autonomousLoop),
+    acceptanceDemo: readAcceptanceDemo(config.acceptanceDemo)
+  };
+}
+function getActiveConfig(config) {
+  const token = config.keepaliveToken ?? config.bridgeToken ?? resolveBridgeTokenRef(config.bridgeTokenRef);
+  if (!config.enabled || !config.serverUrl || !config.communityAgentId || !token) {
+    return null;
+  }
+  return {
+    enabled: true,
+    serverUrl: trimTrailingSlash(config.serverUrl),
+    communityAgentId: config.communityAgentId,
+    connectionToken: token,
+    keepaliveToken: token,
+    bridgeToken: token,
+    pollIntervalMs: config.pollIntervalMs,
+    ...config.communitySubagent ? { communitySubagent: config.communitySubagent } : {},
+    ...config.autonomousLoop ? { autonomousLoop: config.autonomousLoop } : {},
+    ...config.acceptanceDemo ? { acceptanceDemo: config.acceptanceDemo } : {}
+  };
+}
+function resolveBridgeTokenRef(ref) {
+  if (!ref) {
+    return void 0;
+  }
+  if (ref.startsWith("file://")) {
+    return readSecretFile(fileURLToPath(ref));
+  }
+  if (ref.startsWith("/")) {
+    return readSecretFile(ref);
+  }
+  return void 0;
+}
+function readSecretFile(filePath) {
+  try {
+    const value = readFileSync(filePath, "utf8").trim();
+    return value.length > 0 ? value : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function isRecord(value) {
+  return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+function readString(value) {
+  return typeof value === "string" && value.trim().length > 0 ? value.trim() : void 0;
+}
+function readNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function trimTrailingSlash(value) {
+  return value.replace(/\/+$/, "");
+}
+function readAcceptanceDemo(value) {
+  if (!isRecord(value) || value.enabled !== true) {
+    return void 0;
+  }
+  const sessionKey = readString(value.sessionKey);
+  if (!sessionKey) {
+    return void 0;
+  }
+  return {
+    enabled: true,
+    sessionKey,
+    label: readString(value.label)
+  };
+}
+function readCommunitySubagent(value) {
+  if (!isRecord(value)) {
+    return void 0;
+  }
+  return {
+    enabled: value.enabled !== false,
+    agentId: readString(value.agentId),
+    workspaceDir: readString(value.workspaceDir),
+    agentDir: readString(value.agentDir)
+  };
+}
+function readAutonomousLoop(value) {
+  if (!isRecord(value)) {
+    return void 0;
+  }
+  return {
+    enabled: value.enabled === true,
+    maxItemsPerPoll: readPositiveInteger(value.maxItemsPerPoll),
+    timeoutSeconds: readPositiveInteger(value.timeoutSeconds)
+  };
+}
+function readPositiveInteger(value) {
+  return typeof value === "number" && Number.isInteger(value) && value > 0 ? value : void 0;
+}
+
+// src/adapters/openclaw/host-paths.ts
+import { existsSync } from "node:fs";
+import path from "node:path";
+function mergeHostPaths(current, incoming) {
+  return {
+    workspaceDir: incoming.workspaceDir ?? current.workspaceDir,
+    agentDir: incoming.agentDir ?? current.agentDir,
+    stateDir: incoming.stateDir ?? current.stateDir,
+    homeDir: incoming.homeDir ?? current.homeDir,
+    agentId: incoming.agentId ?? current.agentId
+  };
+}
+function inferOpenClawAgentDir(hostPaths) {
+  if (hostPaths.agentDir) {
+    return hostPaths.agentDir;
+  }
+  const agentId = hostPaths.agentId ?? "main";
+  for (const root of [normalizePath(hostPaths.stateDir), normalizePath(hostPaths.workspaceDir)]) {
+    if (!root) {
+      continue;
+    }
+    const candidates = [
+      path.join(root, "agents", agentId, "agent"),
+      path.join(root, ".openclaw", "agents", agentId, "agent")
+    ];
+    const matched = candidates.find((candidate) => existsSync(candidate));
+    if (matched) {
+      return matched;
+    }
+  }
+  return void 0;
+}
+function normalizePath(value) {
+  if (!value || value.trim().length === 0) {
+    return void 0;
+  }
+  return path.resolve(value);
+}
+
+// src/envelope.ts
+import { randomUUID } from "node:crypto";
+function createPostPublishEnvelope(input) {
+  return {
+    envelope_id: `env_${randomUUID()}`,
+    type: "post.publish",
+    sender_agent_id: input.senderAgentId,
+    target: {
+      kind: "public_feed"
+    },
+    visibility: "public",
+    payload: {
+      title: input.title,
+      body: input.body,
+      ...input.intent ? { intent: input.intent } : {},
+      ...input.tags && input.tags.length > 0 ? { tags: input.tags } : {}
+    },
+    reply_to: null,
+    created_at: (/* @__PURE__ */ new Date()).toISOString(),
+    status: "created"
+  };
+}
+function createDirectMessageEnvelope(input) {
+  return {
+    envelope_id: `env_${randomUUID()}`,
+    type: "dm.send",
+    sender_agent_id: input.senderAgentId,
+    target: {
+      kind: "agent",
+      agent_id: input.targetAgentId
+    },
+    visibility: "direct",
+    payload: {
+      message: input.message,
+      ...input.intent ? { intent: input.intent } : {}
+    },
+    reply_to: null,
+    created_at: (/* @__PURE__ */ new Date()).toISOString(),
+    status: "created"
+  };
+}
+function createSkillQueryEnvelope(input) {
+  return {
+    envelope_id: `env_${randomUUID()}`,
+    type: "skill.query",
+    sender_agent_id: input.senderAgentId,
+    target: {
+      kind: "public_feed"
+    },
+    visibility: "private",
+    payload: {
+      need: input.need,
+      ...input.context ? { context: input.context } : {},
+      ...input.tags && input.tags.length > 0 ? { tags: input.tags } : {},
+      ...input.intent ? { intent: input.intent } : {}
+    },
+    reply_to: null,
+    created_at: (/* @__PURE__ */ new Date()).toISOString(),
+    status: "created"
+  };
+}
+function createScheduleNegotiateEnvelope(input) {
+  const payload = {
+    kind: input.kind,
+    negotiation_id: input.negotiationId ?? `neg_${randomUUID()}`,
+    topic: input.topic,
+    duration_minutes: input.durationMinutes,
+    candidate_windows: input.candidateWindows,
+    ...input.selectedWindow ? { selected_window: input.selectedWindow } : {},
+    ...input.reason ? { reason: input.reason } : {}
+  };
+  return {
+    envelope_id: `env_${randomUUID()}`,
+    type: "schedule.negotiate",
+    sender_agent_id: input.senderAgentId,
+    target: {
+      kind: "agent",
+      agent_id: input.targetAgentId
+    },
+    visibility: "direct",
+    acting_for: input.actingFor ?? input.senderAgentId,
+    payload,
+    reply_to: null,
+    created_at: (/* @__PURE__ */ new Date()).toISOString(),
+    status: "created"
+  };
+}
+function createRoomMessageEnvelope(input) {
+  return {
+    envelope_id: `env_${randomUUID()}`,
+    type: "room.message",
+    sender_agent_id: input.senderAgentId,
+    target: {
+      kind: "room",
+      room_id: input.roomId
+    },
+    visibility: "direct",
+    payload: {
+      message: input.message,
+      speaker_kind: input.speakerKind,
+      ...input.speakerLabel ? { speaker_label: input.speakerLabel } : {},
+      ...input.intent ? { intent: input.intent } : {}
+    },
+    reply_to: null,
+    created_at: (/* @__PURE__ */ new Date()).toISOString(),
+    status: "created"
+  };
+}
+
+// src/community-client.ts
+var CommunityClient = class {
+  constructor(config) {
+    this.config = config;
+  }
+  config;
+  async sendKeepalive(cursor, skillOfferCursor, envelopeCursor) {
+    const payload = {
+      community_agent_id: this.config.communityAgentId,
+      keepalive_token: this.config.keepaliveToken,
+      ...cursor ? { cursor } : {},
+      runtime_state: {
+        status: "online",
+        ...skillOfferCursor ? { skill_offer_cursor: skillOfferCursor } : {},
+        ...envelopeCursor ? { envelope_cursor: envelopeCursor } : {}
+      }
+    };
+    const response = await fetch(
+      `${this.config.serverUrl}/v1/agents/${encodeURIComponent(this.config.communityAgentId)}/keepalive`,
+      {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Accept: "application/json"
+        },
+        body: JSON.stringify(payload)
+      }
+    );
+    const body = await readJson(response);
+    if (!response.ok) {
+      throw new Error(`keepalive failed: ${response.status}`);
+    }
+    if (!isKeepaliveResponse(body)) {
+      throw new Error("invalid keepalive response");
+    }
+    return body;
+  }
+  // Legacy compatibility path: the platform primary flow is now keepalive +
+  // envelope. Heartbeat polling is kept temporarily for old acceptance-demo
+  // behavior and should not be expanded as the new mainline.
+  async fetchNextHeartbeat() {
+    const response = await fetch(
+      `${this.config.serverUrl}/v1/agents/${encodeURIComponent(this.config.communityAgentId)}/heartbeat/next`,
+      { headers: this.authHeaders() }
+    );
+    const body = await readJson(response);
+    if (!response.ok) {
+      throw new Error(`heartbeat poll failed: ${response.status}`);
+    }
+    if (isRecord2(body) && body.tick === null) {
+      return null;
+    }
+    const tick = isRecord2(body) && isRecord2(body.tick) ? body.tick : body;
+    return isHeartbeatTick(tick) ? tick : null;
+  }
+  async submitIntent(intent) {
+    const response = await fetch(
+      `${this.config.serverUrl}/v1/agents/${encodeURIComponent(this.config.communityAgentId)}/intents`,
+      {
+        method: "POST",
+        headers: {
+          ...this.authHeaders(),
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify(intent)
+      }
+    );
+    if (!response.ok) {
+      throw new Error(`intent submit failed: ${response.status}`);
+    }
+  }
+  async publishEnvelope(envelope) {
+    const response = await fetch(`${this.config.serverUrl}/v1/envelopes`, {
+      method: "POST",
+      headers: {
+        ...this.authHeaders(),
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(envelope)
+    });
+    const body = await readJson(response);
+    if (!response.ok) {
+      throw new Error(`envelope publish failed: ${response.status}`);
+    }
+    return isRecord2(body) ? {
+      ok: body.ok === true,
+      accepted: body.accepted === true,
+      envelope_id: typeof body.envelope_id === "string" ? body.envelope_id : void 0,
+      dm_id: typeof body.dm_id === "string" ? body.dm_id : void 0,
+      room_id: typeof body.room_id === "string" ? body.room_id : void 0,
+      message_id: typeof body.message_id === "string" ? body.message_id : void 0,
+      delivery_id: typeof body.delivery_id === "string" ? body.delivery_id : void 0,
+      delivery_ids: Array.isArray(body.delivery_ids) ? body.delivery_ids.filter((item) => typeof item === "string") : void 0
+    } : { ok: true };
+  }
+  async createRoom(input) {
+    const response = await fetch(`${this.config.serverUrl}/v1/rooms`, {
+      method: "POST",
+      headers: {
+        ...this.authHeaders(),
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        creator_agent_id: this.config.communityAgentId,
+        topic: input.topic,
+        members: input.members,
+        ...input.sourceNegotiationId ? { source_negotiation_id: input.sourceNegotiationId } : {}
+      })
+    });
+    const body = await readJson(response);
+    if (!response.ok) {
+      throw new Error(`room create failed: ${response.status}`);
+    }
+    if (!isCreateRoomResponse(body)) {
+      throw new Error("invalid create room response");
+    }
+    return body;
+  }
+  async fetchDirectMessages(cursor) {
+    const url = new URL(
+      `${this.config.serverUrl}/v1/agents/${encodeURIComponent(this.config.communityAgentId)}/inbox/direct-messages`
+    );
+    if (cursor) {
+      url.searchParams.set("after", cursor);
+    }
+    const response = await fetch(url, {
+      headers: this.authHeaders()
+    });
+    const body = await readJson(response);
+    if (!response.ok) {
+      throw new Error(`direct message fetch failed: ${response.status}`);
+    }
+    if (!isDirectMessageInboxResponse(body)) {
+      throw new Error("invalid direct message inbox response");
+    }
+    return body;
+  }
+  async fetchEnvelopes(cursor) {
+    const url = new URL(
+      `${this.config.serverUrl}/v1/agents/${encodeURIComponent(this.config.communityAgentId)}/inbox/envelopes`
+    );
+    if (cursor) {
+      url.searchParams.set("after", cursor);
+    }
+    const response = await fetch(url, {
+      headers: this.authHeaders()
+    });
+    const body = await readJson(response);
+    if (!response.ok) {
+      throw new Error(`envelope inbox fetch failed: ${response.status}`);
+    }
+    if (!isEnvelopeInboxResponse(body)) {
+      throw new Error("invalid envelope inbox response");
+    }
+    return body;
+  }
+  async fetchSkillOffers(cursor) {
+    const url = new URL(
+      `${this.config.serverUrl}/v1/agents/${encodeURIComponent(this.config.communityAgentId)}/inbox/skill-offers`
+    );
+    if (cursor) {
+      url.searchParams.set("after", cursor);
+    }
+    const response = await fetch(url, {
+      headers: this.authHeaders()
+    });
+    const body = await readJson(response);
+    if (!response.ok) {
+      throw new Error(`skill offer fetch failed: ${response.status}`);
+    }
+    if (!isSkillOfferInboxResponse(body)) {
+      throw new Error("invalid skill offer inbox response");
+    }
+    return body;
+  }
+  async listAgents() {
+    const response = await fetch(`${this.config.serverUrl}/v1/agents`, {
+      headers: this.authHeaders()
+    });
+    const body = await readJson(response);
+    if (!response.ok) {
+      throw new Error(`agent list fetch failed: ${response.status}`);
+    }
+    if (!isAgentListResponse(body)) {
+      throw new Error("invalid agent list response");
+    }
+    return body;
+  }
+  authHeaders() {
+    return {
+      Authorization: `Bearer ${this.config.connectionToken}`,
+      Accept: "application/json"
+    };
+  }
+};
+async function readJson(response) {
+  const text = await response.text();
+  return text.trim().length > 0 ? JSON.parse(text) : null;
+}
+function isRecord2(value) {
+  return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+function isHeartbeatTick(value) {
+  return isRecord2(value) && typeof value.tick_id === "string" && typeof value.community_agent_id === "string" && typeof value.reason === "string";
+}
+function isKeepaliveResponse(value) {
+  return isRecord2(value) && value.ok === true && typeof value.server_time === "string";
+}
+function isDirectMessageRecord(value) {
+  return isRecord2(value) && typeof value.dm_id === "string" && typeof value.envelope_id === "string" && typeof value.sender_agent_id === "string" && typeof value.recipient_agent_id === "string" && typeof value.message === "string" && typeof value.created_at === "string";
+}
+function isDirectMessageInboxResponse(value) {
+  return isRecord2(value) && value.ok === true && Array.isArray(value.items) && value.items.every((item) => isDirectMessageRecord(item)) && (value.next_cursor === null || typeof value.next_cursor === "string");
+}
+function isEnvelopeInboxResponse(value) {
+  return isRecord2(value) && value.ok === true && Array.isArray(value.items) && value.items.every(
+    (item) => isRecord2(item) && typeof item.delivery_id === "string" && typeof item.envelope_id === "string" && typeof item.sender_agent_id === "string" && typeof item.recipient_agent_id === "string" && typeof item.type === "string" && isRecord2(item.envelope)
+  ) && (value.next_cursor === null || typeof value.next_cursor === "string");
+}
+function isCreateRoomResponse(value) {
+  return isRecord2(value) && value.ok === true && value.accepted === true && isRecord2(value.room) && typeof value.room.room_id === "string" && typeof value.room.topic === "string" && Array.isArray(value.room.members);
+}
+function isSkillOfferRecord(value) {
+  return isRecord2(value) && typeof value.offer_id === "string" && typeof value.envelope_id === "string" && typeof value.sender_agent_id === "string" && typeof value.recipient_agent_id === "string" && typeof value.query_id === "string" && typeof value.skill_slug === "string" && typeof value.name === "string" && typeof value.description === "string" && typeof value.source === "string" && typeof value.risk_level === "string" && typeof value.recommendation_reason === "string" && typeof value.status === "string" && typeof value.created_at === "string";
+}
+function isSkillOfferInboxResponse(value) {
+  return isRecord2(value) && value.ok === true && Array.isArray(value.items) && value.items.every((item) => isSkillOfferRecord(item)) && (value.next_cursor === null || typeof value.next_cursor === "string");
+}
+function isAgentListItem(value) {
+  return isRecord2(value) && typeof value.agent_id === "string" && typeof value.display_name === "string" && typeof value.online === "boolean" && (value.last_keepalive_at === null || typeof value.last_keepalive_at === "undefined" || typeof value.last_keepalive_at === "string");
+}
+function isAgentListResponse(value) {
+  return isRecord2(value) && value.ok === true && Array.isArray(value.items) && value.items.every(isAgentListItem);
+}
+
+// src/intent.ts
+import { randomUUID as randomUUID2 } from "node:crypto";
+function createIntentFromTick(tick) {
+  const acceptanceGreeting = tick.opportunities?.find((item) => item.type === "acceptance_demo_greeting");
+  if (acceptanceGreeting && typeof acceptanceGreeting.message === "string") {
+    return baseIntent(tick, "propose_user_conversation", {
+      topic: "Acceptance demo greeting",
+      reason: "Community heartbeat requested a visible greeting for local acceptance testing.",
+      message: acceptanceGreeting.message,
+      cadence_seconds: typeof acceptanceGreeting.cadence_seconds === "number" ? acceptanceGreeting.cadence_seconds : void 0
+    });
+  }
+  const staleTask = tick.opportunities?.find((item) => item.type === "stale_local_task");
+  if (!staleTask) {
+    return baseIntent(tick, "no_op", {});
+  }
+  return baseIntent(tick, "propose_user_conversation", {
+    topic: "Stale local task",
+    reason: "Heartbeat reported a stale local task.",
+    local_ref: staleTask.local_ref
+  });
+}
+function baseIntent(tick, intentType, payload) {
+  return {
+    intent_id: `intent_${randomUUID2()}`,
+    tick_id: tick.tick_id,
+    community_agent_id: tick.community_agent_id,
+    intent_type: intentType,
+    created_at: (/* @__PURE__ */ new Date()).toISOString(),
+    payload
+  };
+}
+
+// src/workspace.ts
+import { randomUUID as randomUUID3 } from "node:crypto";
+import { mkdir, readFile, readdir, writeFile } from "node:fs/promises";
+import path2 from "node:path";
+
+// src/protocol.ts
+var AGENTCOMM_PROTOCOL_VERSION = "dap-mvp-0.1";
+var AGENTCOMM_BRIDGE_PACKAGE_VERSION = "0.1.2";
+
+// src/workspace.ts
+var WORKSPACE_FOLDER = ".community";
+var STATE_VERSION = 1;
+async function resolvePlatformWorkspacePaths(input) {
+  const rootDir = await resolvePlatformWorkspaceRootDir(input);
+  const strategy = await resolvePlatformWorkspaceStrategy(input);
+  return buildWorkspacePaths(rootDir, strategy);
+}
+async function resolvePlatformWorkspaceRootDir(input) {
+  if (input.agentDir) {
+    return path2.join(input.agentDir, "community");
+  }
+  const scannedAgentDir = await detectSingleAgentDir(input.workspaceDir, input.stateDir, input.homeDir);
+  if (scannedAgentDir) {
+    return path2.join(scannedAgentDir, "community");
+  }
+  const workspaceDir = input.workspaceDir ?? resolveWorkspaceDirFromState(input.stateDir) ?? resolveWorkspaceDirFromStateRoot(process.cwd()) ?? process.cwd();
+  const safeAgentId = sanitizeSegment(input.communityAgentId);
+  return path2.join(workspaceDir, WORKSPACE_FOLDER, safeAgentId);
+}
+async function resolvePlatformWorkspaceStrategy(input) {
+  if (input.agentDir) {
+    return "agentDir";
+  }
+  const scannedAgentDir = await detectSingleAgentDir(input.workspaceDir, input.stateDir, input.homeDir);
+  if (scannedAgentDir) {
+    return "openclaw-state-scan";
+  }
+  return "workspace-fallback";
+}
+function buildWorkspacePaths(rootDir, strategy) {
+  return {
+    strategy,
+    rootDir,
+    inboxDir: path2.join(rootDir, "inbox"),
+    feedCacheDir: path2.join(rootDir, "feed-cache"),
+    outboxDir: path2.join(rootDir, "outbox"),
+    skillsDir: path2.join(rootDir, "skills"),
+    configPatchesDir: path2.join(rootDir, "config-patches"),
+    confirmationsDir: path2.join(rootDir, "confirmations"),
+    personaDir: path2.join(rootDir, "persona"),
+    roomsDir: path2.join(rootDir, "rooms"),
+    workspaceMetaPath: path2.join(rootDir, "workspace.json"),
+    statePath: path2.join(rootDir, "state.json"),
+    personaProfilePath: path2.join(rootDir, "persona", "profile.json"),
+    auditLogPath: path2.join(rootDir, "persona", "audit-log.jsonl"),
+    delegationPolicyPath: path2.join(rootDir, "persona", "delegation-policy.json"),
+    activityLogPath: path2.join(rootDir, "persona", "activity-log.jsonl"),
+    subagentLoopStatePath: path2.join(rootDir, "persona", "subagent-loop-state.json"),
+    receivedDirectMessagesPath: path2.join(rootDir, "inbox", "received-direct-messages.jsonl"),
+    receivedEnvelopesPath: path2.join(rootDir, "inbox", "received-envelopes.jsonl"),
+    sentDirectMessagesPath: path2.join(rootDir, "outbox", "sent-direct-messages.jsonl"),
+    scheduleStatePath: path2.join(rootDir, "persona", "schedule-state.json"),
+    roomsIndexPath: path2.join(rootDir, "rooms", "index.json"),
+    meetingSummariesPath: path2.join(rootDir, "rooms", "meeting-summaries.jsonl"),
+    postsPath: path2.join(rootDir, "feed-cache", "posts.jsonl"),
+    envelopesPath: path2.join(rootDir, "outbox", "envelopes.jsonl"),
+    skillsIndexPath: path2.join(rootDir, "skills", "index.json"),
+    skillOffersPath: path2.join(rootDir, "skills", "offers.jsonl"),
+    skillOffersStagingDir: path2.join(rootDir, "skills", "staging"),
+    pendingActionsPath: path2.join(rootDir, "confirmations", "pending-actions.jsonl"),
+    actionDecisionsPath: path2.join(rootDir, "confirmations", "action-decisions.jsonl"),
+    actionResultsPath: path2.join(rootDir, "confirmations", "action-results.jsonl"),
+    configPatchesIndexPath: path2.join(rootDir, "config-patches", "index.json")
+  };
+}
+function resolveWorkspaceDirFromState(stateDir) {
+  if (!stateDir || !path2.isAbsolute(stateDir)) {
+    return void 0;
+  }
+  return path2.join(stateDir, "workspace");
+}
+function resolveWorkspaceDirFromStateRoot(candidate) {
+  if (!candidate || !path2.isAbsolute(candidate) || path2.basename(candidate) !== ".openclaw") {
+    return void 0;
+  }
+  return path2.join(candidate, "workspace");
+}
+async function detectSingleAgentDir(workspaceDir, stateDir, homeDir) {
+  const roots = [
+    workspaceDir ? path2.join(workspaceDir, ".openclaw", "agents") : void 0,
+    homeDir ? path2.join(homeDir, ".openclaw", "agents") : void 0,
+    stateDir ? path2.join(stateDir, "agents") : void 0,
+    homeDir ? path2.join(homeDir, ".openclaw", "state", "agents") : void 0
+  ].filter((value) => typeof value === "string" && value.length > 0);
+  for (const agentsRoot of roots) {
+    try {
+      const entries = await readdir(agentsRoot, { withFileTypes: true });
+      const agentDirs = entries.filter((entry) => entry.isDirectory()).map((entry) => path2.join(agentsRoot, entry.name, "agent"));
+      if (agentDirs.length === 1) {
+        return agentDirs[0];
+      }
+    } catch {
+    }
+  }
+  return void 0;
+}
+async function ensurePlatformWorkspace(paths, communityAgentId) {
+  await mkdir(paths.inboxDir, { recursive: true });
+  await mkdir(paths.feedCacheDir, { recursive: true });
+  await mkdir(paths.outboxDir, { recursive: true });
+  await mkdir(paths.skillsDir, { recursive: true });
+  await mkdir(paths.skillOffersStagingDir, { recursive: true });
+  await mkdir(paths.configPatchesDir, { recursive: true });
+  await mkdir(paths.confirmationsDir, { recursive: true });
+  await mkdir(paths.personaDir, { recursive: true });
+  await mkdir(paths.roomsDir, { recursive: true });
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const current = await readPlatformWorkspaceState(paths);
+  const state = current ?? {
+    version: STATE_VERSION,
+    communityAgentId,
+    createdAt: now,
+    updatedAt: now
+  };
+  if (!current) {
+    await writePlatformWorkspaceState(paths, state);
+  }
+  await ensureWorkspaceScaffold(paths, communityAgentId);
+  return state;
+}
+async function readPlatformWorkspaceState(paths) {
+  try {
+    const raw = await readFile(paths.statePath, "utf8");
+    const parsed = JSON.parse(raw);
+    if (!isPlatformWorkspaceState(parsed)) {
+      return null;
+    }
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+async function writePlatformWorkspaceState(paths, state) {
+  await writeFile(paths.statePath, JSON.stringify(state, null, 2) + "\n", "utf8");
+}
+async function writePersonaSubagentInfo(paths, communityAgentId, subagent) {
+  let profile;
+  try {
+    const raw = await readFile(paths.personaProfilePath, "utf8");
+    const parsed = JSON.parse(raw);
+    profile = isRecord3(parsed) ? parsed : {};
+  } catch {
+    profile = {};
+  }
+  profile = {
+    ...createInitialPersonaProfile(communityAgentId),
+    ...profile,
+    communityAgentId,
+    personaId: readString2(profile.personaId) ?? `persona_${sanitizeSegment(communityAgentId)}`,
+    subagent
+  };
+  profile.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  await writeFile(paths.personaProfilePath, JSON.stringify(profile, null, 2) + "\n", "utf8");
+}
+async function readPersonaProfile(paths) {
+  try {
+    const raw = await readFile(paths.personaProfilePath, "utf8");
+    const parsed = JSON.parse(raw);
+    return isRecord3(parsed) ? parsed : null;
+  } catch (error) {
+    return {
+      readError: error instanceof Error ? error.message : "unknown persona profile read error",
+      path: paths.personaProfilePath
+    };
+  }
+}
+async function readDelegationPolicy(paths, communityAgentId) {
+  try {
+    const raw = await readFile(paths.delegationPolicyPath, "utf8");
+    const parsed = JSON.parse(raw);
+    if (isDelegationPolicyLike(parsed)) {
+      const policy2 = mergeDelegationPolicyDefaults(parsed, createDefaultDelegationPolicy(communityAgentId));
+      if (JSON.stringify(policy2) !== JSON.stringify(parsed)) {
+        await writeFile(paths.delegationPolicyPath, JSON.stringify(policy2, null, 2) + "\n", "utf8");
+      }
+      return policy2;
+    }
+  } catch {
+  }
+  const policy = createDefaultDelegationPolicy(communityAgentId);
+  await writeFile(paths.delegationPolicyPath, JSON.stringify(policy, null, 2) + "\n", "utf8");
+  return policy;
+}
+function evaluateDelegationPolicy(policy, input) {
+  const matchedRule = policy.rules.find((rule) => rule.action === input.action && rule.risk === input.risk);
+  return {
+    decision: matchedRule?.decision ?? policy.defaultDecision,
+    matchedRuleId: matchedRule?.id ?? null
+  };
+}
+async function appendAuditLog(paths, record) {
+  const audit = {
+    audit_id: `audit_${randomUUID3()}`,
+    created_at: (/* @__PURE__ */ new Date()).toISOString(),
+    ...record
+  };
+  await writeFile(paths.auditLogPath, JSON.stringify(audit) + "\n", { encoding: "utf8", flag: "a" });
+  return audit;
+}
+async function appendAgentActivity(paths, record) {
+  const activity = {
+    activity_id: `act_${randomUUID3()}`,
+    created_at: (/* @__PURE__ */ new Date()).toISOString(),
+    visibility: "user_audit_only",
+    ...record
+  };
+  await writeFile(paths.activityLogPath, JSON.stringify(activity) + "\n", { encoding: "utf8", flag: "a" });
+  return activity;
+}
+async function markWorkspaceKeepalive(paths, communityAgentId, at) {
+  const existing = await readPlatformWorkspaceState(paths);
+  const state = existing ?? {
+    version: STATE_VERSION,
+    communityAgentId,
+    createdAt: at,
+    updatedAt: at
+  };
+  state.lastKeepaliveAt = at;
+  state.updatedAt = at;
+  await writePlatformWorkspaceState(paths, state);
+}
+async function appendWorkspaceEnvelope(paths, communityAgentId, envelope) {
+  const line = JSON.stringify(envelope) + "\n";
+  await writeFile(paths.envelopesPath, line, { encoding: "utf8", flag: "a" });
+  if (envelope.type === "dm.send") {
+    await writeFile(paths.sentDirectMessagesPath, line, { encoding: "utf8", flag: "a" });
+  }
+  if (envelope.type === "post.publish") {
+    await writeFile(paths.postsPath, line, { encoding: "utf8", flag: "a" });
+  }
+  const at = (/* @__PURE__ */ new Date()).toISOString();
+  const existing = await readPlatformWorkspaceState(paths);
+  const state = existing ?? {
+    version: STATE_VERSION,
+    communityAgentId,
+    createdAt: at,
+    updatedAt: at
+  };
+  state.lastEnvelopeAt = at;
+  state.lastEnvelopeId = envelope.envelope_id;
+  state.updatedAt = at;
+  await writePlatformWorkspaceState(paths, state);
+}
+async function appendStagedSkillOffers(paths, communityAgentId, offers, nextCursor) {
+  if (offers.length > 0) {
+    const lines = offers.map((offer) => JSON.stringify(offer)).join("\n") + "\n";
+    await writeFile(paths.skillOffersPath, lines, { encoding: "utf8", flag: "a" });
+    for (const offer of offers) {
+      const manifestPath = path2.join(paths.skillOffersStagingDir, `${sanitizeSegment(offer.offer_id)}.json`);
+      await writeFile(manifestPath, JSON.stringify(offer, null, 2) + "\n", "utf8");
+    }
+    const index = await readSkillOfferIndex(paths);
+    const merged = mergeSkillOffers(index, offers);
+    await writeFile(paths.skillsIndexPath, JSON.stringify(merged, null, 2) + "\n", "utf8");
+  }
+  const at = (/* @__PURE__ */ new Date()).toISOString();
+  const existing = await readPlatformWorkspaceState(paths);
+  const state = existing ?? {
+    version: STATE_VERSION,
+    communityAgentId,
+    createdAt: at,
+    updatedAt: at
+  };
+  state.lastSkillOfferSyncAt = at;
+  if (typeof nextCursor === "string" && nextCursor.length > 0) {
+    state.lastSkillOfferCursor = nextCursor;
+  }
+  state.updatedAt = at;
+  await writePlatformWorkspaceState(paths, state);
+}
+async function appendPendingUserActions(paths, actions) {
+  if (actions.length === 0) {
+    return { ok: true, written: 0, pendingActionsPath: paths.pendingActionsPath };
+  }
+  const existing = await readPendingUserActions(paths);
+  const existingIds = new Set(existing.map((action) => action.action_id));
+  const nextActions = actions.filter((action) => !existingIds.has(action.action_id));
+  if (nextActions.length === 0) {
+    return { ok: true, written: 0, pendingActionsPath: paths.pendingActionsPath };
+  }
+  const lines = nextActions.map((action) => JSON.stringify(action)).join("\n") + "\n";
+  await writeFile(paths.pendingActionsPath, lines, { encoding: "utf8", flag: "a" });
+  return {
+    ok: true,
+    written: nextActions.length,
+    pendingActionsPath: paths.pendingActionsPath
+  };
+}
+async function readPendingUserActions(paths) {
+  try {
+    const raw = await readFile(paths.pendingActionsPath, "utf8");
+    return raw.split(/\r?\n/).filter((line) => line.trim().length > 0).map((line) => JSON.parse(line)).filter(isPendingUserActionLike);
+  } catch {
+    return [];
+  }
+}
+async function readReceivedDirectMessages(paths) {
+  try {
+    const raw = await readFile(paths.receivedDirectMessagesPath, "utf8");
+    return raw.split(/\r?\n/).filter((line) => line.trim().length > 0).map((line) => JSON.parse(line)).filter(isDirectMessageRecordLike);
+  } catch {
+    return [];
+  }
+}
+async function readSentDirectMessages(paths) {
+  try {
+    const raw = await readFile(paths.sentDirectMessagesPath, "utf8");
+    return raw.split(/\r?\n/).filter((line) => line.trim().length > 0).map((line) => JSON.parse(line)).filter(isCommunityEnvelopeLike);
+  } catch {
+    return [];
+  }
+}
+async function readUserActionDecisions(paths) {
+  try {
+    const raw = await readFile(paths.actionDecisionsPath, "utf8");
+    return raw.split(/\r?\n/).filter((line) => line.trim().length > 0).map((line) => JSON.parse(line)).filter(isUserActionDecisionLike);
+  } catch {
+    return [];
+  }
+}
+async function decidePendingUserAction(paths, input) {
+  const actionId = input.actionId.trim();
+  if (actionId.length === 0) {
+    throw new Error("actionId is required");
+  }
+  const actions = await readPendingUserActions(paths);
+  const action = actions.find((item) => item.action_id === actionId);
+  if (!action) {
+    throw new Error(`pending action not found: ${actionId}`);
+  }
+  const decisions = await readUserActionDecisions(paths);
+  const existing = decisions.find((item) => item.action_id === actionId);
+  if (existing) {
+    return {
+      ok: true,
+      actionId,
+      alreadyDecided: true,
+      decision: existing,
+      pendingActionsPath: paths.pendingActionsPath,
+      actionDecisionsPath: paths.actionDecisionsPath
+    };
+  }
+  const decision = {
+    decision_id: `decision_${randomUUID3()}`,
+    action_id: actionId,
+    decision: input.decision,
+    decided_at: (/* @__PURE__ */ new Date()).toISOString(),
+    decided_by: input.decidedBy ?? "bridge",
+    ...input.reason && input.reason.trim().length > 0 ? { reason: input.reason.trim() } : {}
+  };
+  await writeFile(paths.actionDecisionsPath, JSON.stringify(decision) + "\n", { encoding: "utf8", flag: "a" });
+  return {
+    ok: true,
+    actionId,
+    alreadyDecided: false,
+    action,
+    decision,
+    pendingActionsPath: paths.pendingActionsPath,
+    actionDecisionsPath: paths.actionDecisionsPath
+  };
+}
+async function readUserActionResults(paths) {
+  try {
+    const raw = await readFile(paths.actionResultsPath, "utf8");
+    return raw.split(/\r?\n/).filter((line) => line.trim().length > 0).map((line) => JSON.parse(line)).filter(isUserActionResultLike);
+  } catch {
+    return [];
+  }
+}
+async function appendUserActionResult(paths, result) {
+  await writeFile(paths.actionResultsPath, JSON.stringify(result) + "\n", { encoding: "utf8", flag: "a" });
+  return {
+    ok: true,
+    actionId: result.action_id,
+    status: result.status,
+    actionResultsPath: paths.actionResultsPath
+  };
+}
+function createInstallSkillActionResult(actionId, status, payload) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  return {
+    result_id: `result_${randomUUID3()}`,
+    action_id: actionId,
+    kind: "install_skill",
+    status,
+    created_at: now,
+    updated_at: now,
+    payload
+  };
+}
+function createSkillOfferPendingActions(communityAgentId, offers) {
+  const createdAt = (/* @__PURE__ */ new Date()).toISOString();
+  return offers.map((offer) => ({
+    action_id: `action_install_skill_${sanitizeSegment(offer.offer_id)}`,
+    kind: "install_skill",
+    source: "openclaw-bridge",
+    community_agent_id: communityAgentId,
+    status: "pending_user_confirmation",
+    user_confirmation_required: true,
+    created_at: createdAt,
+    title: `\u5B89\u88C5 Skill\uFF1A${offer.name || offer.skill_slug}`,
+    summary: offer.recommendation_reason,
+    payload: {
+      offer_id: offer.offer_id,
+      skill_slug: offer.skill_slug,
+      name: offer.name,
+      description: offer.description,
+      risk_level: offer.risk_level,
+      install_hint: offer.install_hint,
+      source: offer.source,
+      created_at: offer.created_at
+    }
+  }));
+}
+async function appendSubagentHandoffItems(subagentWorkspaceDir, communityAgentId, items) {
+  if (!subagentWorkspaceDir || items.length === 0) {
+    return { ok: false, written: 0, reason: "subagent workspace unavailable" };
+  }
+  const paths = resolveSubagentHandoffPaths(subagentWorkspaceDir);
+  await mkdir(paths.inboxDir, { recursive: true });
+  const lines = items.map((item) => JSON.stringify(item)).join("\n") + "\n";
+  await writeFile(paths.queuePath, lines, { encoding: "utf8", flag: "a" });
+  return {
+    ok: true,
+    written: items.length,
+    communityAgentId,
+    queuePath: paths.queuePath
+  };
+}
+async function readSubagentHandoffItems(subagentWorkspaceDir) {
+  if (!subagentWorkspaceDir) {
+    return [];
+  }
+  try {
+    const paths = resolveSubagentHandoffPaths(subagentWorkspaceDir);
+    const raw = await readFile(paths.queuePath, "utf8");
+    return raw.split(/\n+/).filter(Boolean).map((line) => JSON.parse(line)).filter(isSubagentHandoffItemLike);
+  } catch {
+    return [];
+  }
+}
+async function readSubagentLoopState(paths) {
+  try {
+    const raw = await readFile(paths.subagentLoopStatePath, "utf8");
+    const parsed = JSON.parse(raw);
+    if (isSubagentLoopStateLike(parsed)) {
+      return parsed;
+    }
+  } catch {
+  }
+  return {
+    version: 1,
+    processedHandoffIds: []
+  };
+}
+async function writeSubagentLoopState(paths, state) {
+  const nextState = {
+    version: 1,
+    processedHandoffIds: [...new Set(state.processedHandoffIds)].slice(-500),
+    ...state.lastRunAt ? { lastRunAt: state.lastRunAt } : {},
+    ...state.lastProcessedHandoffId ? { lastProcessedHandoffId: state.lastProcessedHandoffId } : {},
+    ...state.lastError ? { lastError: state.lastError } : {}
+  };
+  await writeFile(paths.subagentLoopStatePath, JSON.stringify(nextState, null, 2) + "\n", "utf8");
+  return nextState;
+}
+function createDirectMessageHandoffItems(communityAgentId, messages) {
+  const receivedAt = (/* @__PURE__ */ new Date()).toISOString();
+  return messages.map((message) => ({
+    handoff_id: `handoff_${randomUUID3()}`,
+    kind: "direct_message",
+    source: "openclaw-bridge",
+    community_agent_id: communityAgentId,
+    envelope_id: message.envelope_id,
+    status: "pending_subagent_review",
+    user_confirmation_required: false,
+    received_at: receivedAt,
+    payload: {
+      dm_id: message.dm_id,
+      sender_agent_id: message.sender_agent_id,
+      recipient_agent_id: message.recipient_agent_id,
+      message: message.message,
+      intent: message.intent ?? null,
+      visibility: message.visibility ?? "direct",
+      created_at: message.created_at
+    }
+  }));
+}
+function createSkillOfferHandoffItems(communityAgentId, offers) {
+  const receivedAt = (/* @__PURE__ */ new Date()).toISOString();
+  return offers.map((offer) => ({
+    handoff_id: `handoff_${randomUUID3()}`,
+    kind: "skill_offer",
+    source: "openclaw-bridge",
+    community_agent_id: communityAgentId,
+    envelope_id: offer.envelope_id,
+    status: "pending_subagent_review",
+    user_confirmation_required: true,
+    received_at: receivedAt,
+    payload: {
+      offer_id: offer.offer_id,
+      skill_slug: offer.skill_slug,
+      name: offer.name,
+      description: offer.description,
+      recommendation_reason: offer.recommendation_reason,
+      risk_level: offer.risk_level,
+      status: offer.status,
+      install_hint: offer.install_hint,
+      created_at: offer.created_at
+    }
+  }));
+}
+function createMeetingSummaryHandoffItem(communityAgentId, input) {
+  const receivedAt = (/* @__PURE__ */ new Date()).toISOString();
+  return {
+    handoff_id: `handoff_meeting_summary_${sanitizeSegment(input.room.room_id)}_${randomUUID3()}`,
+    kind: "meeting_summary",
+    source: "openclaw-bridge",
+    community_agent_id: communityAgentId,
+    envelope_id: `room_transcript_${sanitizeSegment(input.room.room_id)}`,
+    status: "pending_subagent_review",
+    user_confirmation_required: true,
+    received_at: receivedAt,
+    payload: {
+      room_id: input.room.room_id,
+      topic: input.room.topic,
+      members: input.room.members,
+      timezone: input.timezone,
+      current_date: input.currentDate,
+      current_time: input.currentTime,
+      transcript: input.messages.map((message) => ({
+        message_id: message.message_id ?? null,
+        envelope_id: message.envelope_id,
+        sender_agent_id: message.sender_agent_id,
+        speaker_kind: message.speaker_kind,
+        speaker_label: message.speaker_label ?? null,
+        message: message.message,
+        created_at: message.created_at
+      }))
+    }
+  };
+}
+function createDirectMessageReplyPendingActions(communityAgentId, messages) {
+  const createdAt = (/* @__PURE__ */ new Date()).toISOString();
+  return messages.map((message) => ({
+    action_id: `action_reply_dm_${sanitizeSegment(message.dm_id)}`,
+    kind: "reply_to_dm",
+    source: "openclaw-bridge",
+    community_agent_id: communityAgentId,
+    status: "pending_user_confirmation",
+    user_confirmation_required: true,
+    created_at: createdAt,
+    title: `\u56DE\u590D ${message.sender_agent_id}`,
+    summary: `\u6536\u5230\u4E00\u6761\u9700\u8981\u7528\u6237\u51B3\u5B9A\u5982\u4F55\u56DE\u590D\u7684\u79C1\u4FE1\uFF1A${message.message}`,
+    payload: {
+      dm_id: message.dm_id,
+      envelope_id: message.envelope_id,
+      sender_agent_id: message.sender_agent_id,
+      recipient_agent_id: message.recipient_agent_id,
+      message: message.message,
+      intent: message.intent ?? null,
+      risk_level: "medium",
+      suggested_action: "ask_user_to_reply",
+      created_at: message.created_at
+    }
+  }));
+}
+function resolveSubagentHandoffPaths(subagentWorkspaceDir) {
+  const rootDir = path2.join(subagentWorkspaceDir, ".agentcomm");
+  return {
+    rootDir,
+    inboxDir: path2.join(rootDir, "inbox"),
+    queuePath: path2.join(rootDir, "inbox", "handoff.jsonl")
+  };
+}
+async function readStagedSkillOffers(paths) {
+  try {
+    const entries = await readdir(paths.skillOffersStagingDir, { withFileTypes: true });
+    const offers = [];
+    for (const entry of entries) {
+      if (!entry.isFile() || !entry.name.endsWith(".json")) {
+        continue;
+      }
+      const raw = await readFile(path2.join(paths.skillOffersStagingDir, entry.name), "utf8");
+      const parsed = JSON.parse(raw);
+      if (isSkillOfferRecordLike(parsed)) {
+        offers.push(parsed);
+      }
+    }
+    return offers.sort((a, b) => String(b.created_at).localeCompare(String(a.created_at)));
+  } catch {
+    return [];
+  }
+}
+async function writeStagedSkillOffer(paths, offer) {
+  const manifestPath = path2.join(paths.skillOffersStagingDir, `${sanitizeSegment(offer.offer_id)}.json`);
+  await writeFile(manifestPath, JSON.stringify(offer, null, 2) + "\n", "utf8");
+  const index = await readSkillOfferIndex(paths);
+  const merged = mergeSkillOffers(index, [offer]);
+  await writeFile(paths.skillsIndexPath, JSON.stringify(merged, null, 2) + "\n", "utf8");
+}
+async function appendReceivedDirectMessages(paths, communityAgentId, messages, nextCursor) {
+  if (messages.length > 0) {
+    const lines = messages.map((message) => JSON.stringify(message)).join("\n") + "\n";
+    await writeFile(paths.receivedDirectMessagesPath, lines, { encoding: "utf8", flag: "a" });
+  }
+  const at = (/* @__PURE__ */ new Date()).toISOString();
+  const existing = await readPlatformWorkspaceState(paths);
+  const state = existing ?? {
+    version: STATE_VERSION,
+    communityAgentId,
+    createdAt: at,
+    updatedAt: at
+  };
+  state.lastInboxSyncAt = at;
+  if (typeof nextCursor === "string" && nextCursor.length > 0) {
+    state.lastInboxCursor = nextCursor;
+  }
+  state.updatedAt = at;
+  await writePlatformWorkspaceState(paths, state);
+}
+async function appendReceivedEnvelopes(paths, communityAgentId, items, nextCursor) {
+  if (items.length > 0) {
+    const lines = items.map((item) => JSON.stringify(item)).join("\n") + "\n";
+    await writeFile(paths.receivedEnvelopesPath, lines, { encoding: "utf8", flag: "a" });
+  }
+  const at = (/* @__PURE__ */ new Date()).toISOString();
+  const existing = await readPlatformWorkspaceState(paths);
+  const state = existing ?? {
+    version: STATE_VERSION,
+    communityAgentId,
+    createdAt: at,
+    updatedAt: at
+  };
+  state.lastEnvelopeSyncAt = at;
+  if (typeof nextCursor === "string" && nextCursor.length > 0) {
+    state.lastEnvelopeCursor = nextCursor;
+  }
+  state.updatedAt = at;
+  await writePlatformWorkspaceState(paths, state);
+}
+async function readScheduleState(paths) {
+  try {
+    const raw = await readFile(paths.scheduleStatePath, "utf8");
+    const parsed = JSON.parse(raw);
+    return isRecord3(parsed) ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+async function writeScheduleState(paths, state) {
+  await writeFile(paths.scheduleStatePath, JSON.stringify(state, null, 2) + "\n", "utf8");
+}
+async function readRooms(paths) {
+  try {
+    const raw = await readFile(paths.roomsIndexPath, "utf8");
+    const parsed = JSON.parse(raw);
+    return Array.isArray(parsed) ? parsed.filter(isRoomRecordLike) : [];
+  } catch {
+    return [];
+  }
+}
+async function upsertRoom(paths, room) {
+  const rooms = await readRooms(paths);
+  const byId = new Map(rooms.map((item) => [item.room_id, item]));
+  byId.set(room.room_id, room);
+  const next = [...byId.values()].sort((a, b) => timeValue(b.updated_at) - timeValue(a.updated_at));
+  await writeFile(paths.roomsIndexPath, JSON.stringify(next, null, 2) + "\n", "utf8");
+  return room;
+}
+async function readRoomMessages(paths, roomId) {
+  try {
+    const raw = await readFile(roomMessagesPath(paths, roomId), "utf8");
+    return raw.split(/\r?\n/).filter((line) => line.trim().length > 0).map((line) => JSON.parse(line)).filter(isRoomMessageRecordLike);
+  } catch {
+    return [];
+  }
+}
+async function writeMeetingSummary(paths, summary) {
+  await mkdir(paths.roomsDir, { recursive: true });
+  await writeFile(paths.meetingSummariesPath, JSON.stringify(summary) + "\n", { encoding: "utf8", flag: "a" });
+  await writeFile(
+    path2.join(paths.roomsDir, `${sanitizeSegment(summary.room_id)}.summary.json`),
+    JSON.stringify(summary, null, 2) + "\n",
+    "utf8"
+  );
+  return summary;
+}
+async function appendRoomMessages(paths, messages) {
+  const byRoom = /* @__PURE__ */ new Map();
+  for (const message of messages) {
+    if (!message.room_id) continue;
+    const items = byRoom.get(message.room_id) ?? [];
+    items.push(message);
+    byRoom.set(message.room_id, items);
+  }
+  for (const [roomId, items] of byRoom.entries()) {
+    await mkdir(paths.roomsDir, { recursive: true });
+    const existing = await readRoomMessages(paths, roomId);
+    const existingEnvelopeIds = new Set(existing.map((message) => message.envelope_id));
+    const next = items.filter((message) => !existingEnvelopeIds.has(message.envelope_id));
+    if (next.length > 0) {
+      await writeFile(roomMessagesPath(paths, roomId), next.map((message) => JSON.stringify(message)).join("\n") + "\n", {
+        encoding: "utf8",
+        flag: "a"
+      });
+    }
+  }
+}
+async function ensureWorkspaceScaffold(paths, communityAgentId) {
+  const meta = {
+    version: STATE_VERSION,
+    communityAgentId,
+    strategy: paths.strategy,
+    rootDir: paths.rootDir,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    layout: {
+      persona: paths.personaDir,
+      inbox: paths.inboxDir,
+      feedCache: paths.feedCacheDir,
+      outbox: paths.outboxDir,
+      skills: paths.skillsDir,
+      confirmations: paths.confirmationsDir,
+      configPatches: paths.configPatchesDir,
+      rooms: paths.roomsDir
+    }
+  };
+  await ensureFile(paths.workspaceMetaPath, JSON.stringify(meta, null, 2) + "\n");
+  await ensureFile(
+    paths.personaProfilePath,
+    JSON.stringify(createInitialPersonaProfile(communityAgentId), null, 2) + "\n"
+  );
+  await ensureFile(paths.auditLogPath, "");
+  await ensureFile(paths.activityLogPath, "");
+  await ensureFile(paths.subagentLoopStatePath, JSON.stringify({ version: 1, processedHandoffIds: [] }, null, 2) + "\n");
+  await ensureFile(paths.delegationPolicyPath, JSON.stringify(createDefaultDelegationPolicy(communityAgentId), null, 2) + "\n");
+  await ensureFile(paths.receivedDirectMessagesPath, "");
+  await ensureFile(paths.receivedEnvelopesPath, "");
+  await ensureFile(paths.sentDirectMessagesPath, "");
+  await ensureFile(paths.scheduleStatePath, "{}\n");
+  await ensureFile(paths.roomsIndexPath, "[]\n");
+  await ensureFile(paths.meetingSummariesPath, "");
+  await ensureFile(paths.postsPath, "");
+  await ensureFile(paths.envelopesPath, "");
+  await ensureFile(paths.skillsIndexPath, "[]\n");
+  await ensureFile(paths.skillOffersPath, "");
+  await ensureFile(paths.pendingActionsPath, "");
+  await ensureFile(paths.actionDecisionsPath, "");
+  await ensureFile(paths.actionResultsPath, "");
+  await ensureFile(paths.configPatchesIndexPath, "[]\n");
+}
+function createInitialPersonaProfile(communityAgentId) {
+  return {
+    version: 1,
+    personaId: `persona_${sanitizeSegment(communityAgentId)}`,
+    communityAgentId,
+    displayName: communityAgentId,
+    mode: "bridge-managed-workspace",
+    trustBoundary: "community-inputs-remain-in-persona-workspace-until-user-confirmation",
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    profile: {
+      bio: "Local Community Persona scaffold for AgentComm MVP.",
+      allowedCommunityActions: ["post.publish", "dm.send", "skill.query", "skill.offer.stage"]
+    }
+  };
+}
+function createDefaultDelegationPolicy(communityAgentId) {
+  return {
+    protocolVersion: AGENTCOMM_PROTOCOL_VERSION,
+    principal: {
+      userId: "local-user",
+      mainAgentId: "openclaw-main",
+      communityAgentId
+    },
+    defaultDecision: "ask",
+    rules: [
+      {
+        id: "allow-low-risk-dm-receipt",
+        action: "dm.receipt",
+        risk: "low",
+        decision: "allow"
+      },
+      {
+        id: "allow-low-risk-dm-send",
+        action: "dm.send",
+        risk: "low",
+        decision: "allow"
+      },
+      {
+        id: "ask-medium-risk-dm-reply",
+        action: "dm.reply",
+        risk: "medium",
+        decision: "ask"
+      },
+      {
+        id: "allow-schedule-propose",
+        action: "schedule.negotiate.propose",
+        risk: "low",
+        decision: "allow"
+      },
+      {
+        id: "allow-schedule-counter",
+        action: "schedule.negotiate.counter",
+        risk: "low",
+        decision: "allow"
+      },
+      {
+        id: "allow-schedule-agree-pending",
+        action: "schedule.negotiate.agree_pending",
+        risk: "low",
+        decision: "allow"
+      },
+      {
+        id: "allow-schedule-decline",
+        action: "schedule.negotiate.decline",
+        risk: "low",
+        decision: "allow"
+      },
+      {
+        id: "allow-room-message-send",
+        action: "room.message.send",
+        risk: "low",
+        decision: "allow"
+      },
+      {
+        id: "allow-room-message-receive",
+        action: "room.message.receive",
+        risk: "low",
+        decision: "allow"
+      },
+      {
+        id: "ask-meeting-summary",
+        action: "meeting.summary",
+        risk: "medium",
+        decision: "ask"
+      },
+      {
+        id: "ask-schedule-commit",
+        action: "schedule.negotiate.commit",
+        risk: "medium",
+        decision: "ask"
+      }
+    ],
+    audit: {
+      required: true
+    },
+    autoReceipt: {
+      enabled: true,
+      message: "\u5DF2\u6536\u5230\uFF0C\u4F1A\u8F6C\u544A\u6211\u7684\u7528\u6237\u3002"
+    },
+    scheduling: {
+      timezone: Intl.DateTimeFormat().resolvedOptions().timeZone,
+      available_windows: [
+        {
+          start: "2026-06-18T09:00:00+08:00",
+          end: "2026-06-18T11:00:00+08:00"
+        },
+        {
+          start: "2026-06-18T14:00:00+08:00",
+          end: "2026-06-18T15:00:00+08:00"
+        }
+      ]
+    }
+  };
+}
+function mergeDelegationPolicyDefaults(policy, defaults) {
+  const existingRuleIds = new Set(policy.rules.map((rule) => rule.id));
+  const missingDefaultRules = defaults.rules.filter((rule) => !existingRuleIds.has(rule.id));
+  return {
+    ...defaults,
+    ...policy,
+    principal: {
+      ...defaults.principal,
+      ...policy.principal,
+      communityAgentId: policy.principal?.communityAgentId ?? defaults.principal.communityAgentId
+    },
+    rules: [...policy.rules, ...missingDefaultRules],
+    audit: policy.audit ?? defaults.audit,
+    autoReceipt: policy.autoReceipt ?? defaults.autoReceipt,
+    scheduling: policy.scheduling ?? defaults.scheduling
+  };
+}
+async function readSkillOfferIndex(paths) {
+  try {
+    const raw = await readFile(paths.skillsIndexPath, "utf8");
+    const parsed = JSON.parse(raw);
+    return Array.isArray(parsed) ? parsed.filter(isSkillOfferRecordLike) : [];
+  } catch {
+    return [];
+  }
+}
+function mergeSkillOffers(existing, incoming) {
+  const byOfferId = new Map(existing.map((offer) => [offer.offer_id, offer]));
+  for (const offer of incoming) {
+    byOfferId.set(offer.offer_id, offer);
+  }
+  return [...byOfferId.values()].sort((a, b) => String(b.created_at).localeCompare(String(a.created_at)));
+}
+async function ensureFile(filePath, initialContent) {
+  try {
+    await readFile(filePath, "utf8");
+  } catch {
+    await writeFile(filePath, initialContent, "utf8");
+  }
+}
+function sanitizeSegment(value) {
+  return value.replace(/[^a-zA-Z0-9._-]+/g, "_");
+}
+function readString2(value) {
+  return typeof value === "string" && value.trim().length > 0 ? value.trim() : void 0;
+}
+function isRecord3(value) {
+  return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+function isPlatformWorkspaceState(value) {
+  return Boolean(
+    value && typeof value === "object" && !Array.isArray(value) && value.version === STATE_VERSION && typeof value.communityAgentId === "string" && typeof value.createdAt === "string" && typeof value.updatedAt === "string"
+  );
+}
+function isSkillOfferRecordLike(value) {
+  return Boolean(
+    value && typeof value === "object" && !Array.isArray(value) && typeof value.offer_id === "string" && typeof value.skill_slug === "string"
+  );
+}
+function isDirectMessageRecordLike(value) {
+  return Boolean(
+    value && typeof value === "object" && !Array.isArray(value) && typeof value.dm_id === "string" && typeof value.envelope_id === "string" && typeof value.sender_agent_id === "string" && typeof value.recipient_agent_id === "string" && typeof value.message === "string" && typeof value.created_at === "string"
+  );
+}
+function isRoomRecordLike(value) {
+  return Boolean(
+    value && typeof value === "object" && !Array.isArray(value) && typeof value.room_id === "string" && typeof value.topic === "string" && Array.isArray(value.members) && typeof value.created_by_agent_id === "string" && (value.status === "open" || value.status === "closed") && typeof value.created_at === "string" && typeof value.updated_at === "string"
+  );
+}
+function isRoomMessageRecordLike(value) {
+  return Boolean(
+    value && typeof value === "object" && !Array.isArray(value) && typeof value.room_id === "string" && typeof value.envelope_id === "string" && typeof value.sender_agent_id === "string" && (value.speaker_kind === "human" || value.speaker_kind === "agent") && typeof value.message === "string" && typeof value.created_at === "string"
+  );
+}
+function isSubagentHandoffItemLike(value) {
+  return Boolean(
+    value && typeof value === "object" && !Array.isArray(value) && typeof value.handoff_id === "string" && (value.kind === "direct_message" || value.kind === "skill_offer" || value.kind === "meeting_summary") && value.source === "openclaw-bridge" && typeof value.community_agent_id === "string" && typeof value.envelope_id === "string" && typeof value.received_at === "string" && isRecord3(value.payload)
+  );
+}
+function isSubagentLoopStateLike(value) {
+  return Boolean(
+    value && typeof value === "object" && !Array.isArray(value) && value.version === 1 && Array.isArray(value.processedHandoffIds) && value.processedHandoffIds.every((item) => typeof item === "string")
+  );
+}
+function isCommunityEnvelopeLike(value) {
+  return Boolean(
+    value && typeof value === "object" && !Array.isArray(value) && typeof value.envelope_id === "string" && typeof value.type === "string" && typeof value.sender_agent_id === "string"
+  );
+}
+function isPendingUserActionLike(value) {
+  return Boolean(
+    value && typeof value === "object" && !Array.isArray(value) && typeof value.action_id === "string" && (value.kind === "install_skill" || value.kind === "reply_to_dm" || value.kind === "commit_schedule" || value.kind === "meeting_summary") && value.status === "pending_user_confirmation"
+  );
+}
+function isDelegationPolicyLike(value) {
+  return Boolean(
+    value && typeof value === "object" && !Array.isArray(value) && value.protocolVersion === AGENTCOMM_PROTOCOL_VERSION && value.defaultDecision === "ask" && Array.isArray(value.rules)
+  );
+}
+function isUserActionDecisionLike(value) {
+  return Boolean(
+    value && typeof value === "object" && !Array.isArray(value) && typeof value.decision_id === "string" && typeof value.action_id === "string" && (value.decision === "accepted" || value.decision === "rejected") && typeof value.decided_at === "string"
+  );
+}
+function isUserActionResultLike(value) {
+  return Boolean(
+    value && typeof value === "object" && !Array.isArray(value) && typeof value.result_id === "string" && typeof value.action_id === "string" && (value.status === "installing" || value.status === "installed" || value.status === "install_failed" || value.status === "committed" || value.status === "recorded")
+  );
+}
+function roomMessagesPath(paths, roomId) {
+  return path2.join(paths.roomsDir, `${sanitizeSegment(roomId)}.jsonl`);
+}
+function timeValue(value) {
+  const time = Date.parse(value ?? "");
+  return Number.isFinite(time) ? time : 0;
+}
+
+// src/schedule.ts
+var SCHEDULE_NEGOTIATE_KINDS = [
+  "propose",
+  "counter",
+  "agree_pending",
+  "commit",
+  "decline"
+];
+function isScheduleNegotiateEnvelope(envelope) {
+  return envelope.type === "schedule.negotiate" && isScheduleNegotiatePayload(envelope.payload) && envelope.target.kind === "agent" && typeof envelope.target.agent_id === "string";
+}
+function isScheduleNegotiatePayload(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+  const record = value;
+  return SCHEDULE_NEGOTIATE_KINDS.includes(record.kind) && typeof record.negotiation_id === "string" && typeof record.topic === "string" && typeof record.duration_minutes === "number" && Number.isFinite(record.duration_minutes) && Array.isArray(record.candidate_windows) && record.candidate_windows.every(isScheduleWindow) && (!record.selected_window || isScheduleWindow(record.selected_window));
+}
+function getSchedulingAvailableWindows(policy) {
+  const windows = policy.scheduling?.available_windows;
+  if (Array.isArray(windows) && windows.every(isScheduleWindow)) {
+    return windows;
+  }
+  return [
+    {
+      start: "2026-06-18T09:00:00+08:00",
+      end: "2026-06-18T11:00:00+08:00"
+    },
+    {
+      start: "2026-06-18T14:00:00+08:00",
+      end: "2026-06-18T15:00:00+08:00"
+    }
+  ];
+}
+function intersectScheduleWindows(incoming, available, durationMinutes) {
+  const durationMs = durationMinutes * 6e4;
+  const intersections = [];
+  for (const left of incoming) {
+    for (const right of available) {
+      const startMs = Math.max(Date.parse(left.start), Date.parse(right.start));
+      const endMs = Math.min(Date.parse(left.end), Date.parse(right.end));
+      if (!Number.isFinite(startMs) || !Number.isFinite(endMs)) continue;
+      if (endMs - startMs >= durationMs) {
+        intersections.push({
+          start: new Date(startMs).toISOString(),
+          end: new Date(Math.min(endMs, startMs + durationMs)).toISOString()
+        });
+      }
+    }
+  }
+  return dedupeWindows(intersections);
+}
+function createScheduleCommitPendingAction(communityAgentId, envelope, selectedWindow, options) {
+  return {
+    action_id: `action_commit_schedule_${sanitizeSegment2(envelope.payload.negotiation_id)}`,
+    kind: "commit_schedule",
+    source: "openclaw-bridge",
+    community_agent_id: communityAgentId,
+    status: "pending_user_confirmation",
+    user_confirmation_required: true,
+    created_at: (/* @__PURE__ */ new Date()).toISOString(),
+    title: `\u786E\u8BA4\u4F1A\u8BAE\uFF1A${envelope.payload.topic}`,
+    summary: `\u5019\u9009\u65F6\u95F4\u5DF2\u6536\u655B\uFF0C\u662F\u5426\u627F\u8BFA ${selectedWindow.start} - ${selectedWindow.end}\uFF1F`,
+    payload: {
+      negotiation_id: envelope.payload.negotiation_id,
+      topic: envelope.payload.topic,
+      duration_minutes: envelope.payload.duration_minutes,
+      selected_window: selectedWindow,
+      peer_agent_id: options?.peerAgentId ?? envelope.sender_agent_id,
+      inbound_envelope_id: options?.inboundEnvelopeId ?? envelope.envelope_id,
+      risk_level: "medium",
+      suggested_action: "confirm_calendar_commitment"
+    }
+  };
+}
+function updateScheduleState(current, state) {
+  const negotiations = current.negotiations && typeof current.negotiations === "object" && !Array.isArray(current.negotiations) ? { ...current.negotiations } : {};
+  negotiations[state.negotiation_id] = state;
+  return {
+    version: 1,
+    updated_at: (/* @__PURE__ */ new Date()).toISOString(),
+    ...current,
+    negotiations
+  };
+}
+function createScheduleStateFromEnvelope(envelope, status, candidateWindows, selectedWindow, options) {
+  return {
+    negotiation_id: envelope.payload.negotiation_id,
+    topic: envelope.payload.topic,
+    duration_minutes: envelope.payload.duration_minutes,
+    peer_agent_id: options?.peerAgentId ?? envelope.sender_agent_id,
+    status,
+    candidate_windows: candidateWindows,
+    ...selectedWindow ? { selected_window: selectedWindow } : {},
+    last_envelope_id: envelope.envelope_id,
+    updated_at: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function isScheduleWindow(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value) && typeof value.start === "string" && typeof value.end === "string" && Number.isFinite(Date.parse(value.start)) && Number.isFinite(Date.parse(value.end)) && Date.parse(value.start) < Date.parse(value.end);
+}
+function dedupeWindows(windows) {
+  const byKey = /* @__PURE__ */ new Map();
+  for (const window of windows) {
+    byKey.set(`${window.start}|${window.end}`, window);
+  }
+  return [...byKey.values()].sort((a, b) => Date.parse(a.start) - Date.parse(b.start));
+}
+function sanitizeSegment2(value) {
+  return value.replace(/[^a-zA-Z0-9._-]+/g, "_");
+}
+
+// src/service.ts
+function createCommunityBridgeService(readConfig, readHostPaths) {
+  let timer;
+  let running = false;
+  let workspacePaths;
+  let status = {
+    enabled: false,
+    connected: false,
+    running: false
+  };
+  async function ensureWorkspaceForActiveConfig(config) {
+    const hostPaths = readHostPaths();
+    const locator = {
+      communityAgentId: config.communityAgentId,
+      workspaceDir: hostPaths.workspaceDir,
+      agentDir: inferOpenClawAgentDir(hostPaths),
+      stateDir: hostPaths.stateDir,
+      homeDir: hostPaths.homeDir
+    };
+    const paths = await resolvePlatformWorkspacePaths(locator);
+    await ensurePlatformWorkspace(paths, config.communityAgentId);
+    workspacePaths = paths;
+    return paths;
+  }
+  async function evaluateOutboundDmPolicy(paths, communityAgentId, _targetAgentId, _envelopeId) {
+    const policy = await readDelegationPolicy(paths, communityAgentId);
+    return evaluateDelegationPolicy(policy, { action: "dm.send", risk: "low" });
+  }
+  async function evaluateSchedulePolicy(paths, communityAgentId, kind) {
+    const policy = await readDelegationPolicy(paths, communityAgentId);
+    const risk = kind === "commit" ? "medium" : "low";
+    return {
+      policy,
+      risk,
+      policyResult: evaluateDelegationPolicy(policy, { action: `schedule.negotiate.${kind}`, risk })
+    };
+  }
+  async function handleInboundDirectMessages(config, client, paths, messages) {
+    if (messages.length === 0) {
+      return;
+    }
+    const policy = await readDelegationPolicy(paths, config.communityAgentId);
+    const askMessages = [];
+    for (const message of messages) {
+      const risk = classifyDirectMessageRisk(message);
+      const action = risk === "low" ? "dm.receipt" : "dm.reply";
+      const policyResult = evaluateDelegationPolicy(policy, { action, risk });
+      await appendAuditLog(paths, {
+        kind: "policy_decision",
+        community_agent_id: config.communityAgentId,
+        action,
+        decision: policyResult.decision,
+        reason: `inbound dm risk=${risk}; matched=${policyResult.matchedRuleId ?? "default"}`,
+        source_event_id: message.dm_id,
+        envelope_id: message.envelope_id,
+        dm_id: message.dm_id,
+        target_agent_id: message.sender_agent_id,
+        result: policyResult.decision,
+        payload: {
+          message: message.message
+        }
+      });
+      if (risk === "low" && policyResult.decision === "allow" && policy.autoReceipt.enabled) {
+        const receipt = createDirectMessageEnvelope({
+          senderAgentId: config.communityAgentId,
+          targetAgentId: message.sender_agent_id,
+          message: policy.autoReceipt.message,
+          intent: "agentcomm.auto_receipt"
+        });
+        const publishResult = await client.publishEnvelope(receipt);
+        await appendWorkspaceEnvelope(paths, config.communityAgentId, receipt);
+        await appendAuditLog(paths, {
+          kind: "dm.auto_receipt",
+          community_agent_id: config.communityAgentId,
+          action: "dm.send",
+          decision: "allow",
+          reason: `auto receipt for ${message.dm_id}`,
+          source_event_id: message.dm_id,
+          envelope_id: receipt.envelope_id,
+          dm_id: publishResult.dm_id,
+          target_agent_id: message.sender_agent_id,
+          result: "sent",
+          payload: {
+            inbound_envelope_id: message.envelope_id,
+            inbound_dm_id: message.dm_id,
+            intent: "agentcomm.auto_receipt"
+          }
+        });
+        await appendAgentActivity(paths, {
+          kind: "dm.auto_receipt",
+          risk_level: "low",
+          summary: `\u5DF2\u81EA\u52A8\u5411 ${message.sender_agent_id} \u53D1\u9001\u6536\u5230\u56DE\u6267\u3002`,
+          source_agent_id: message.sender_agent_id,
+          target_agent_id: config.communityAgentId,
+          source_event_id: message.dm_id,
+          payload: {
+            receipt_envelope_id: receipt.envelope_id,
+            matched_rule_id: policyResult.matchedRuleId
+          }
+        });
+        continue;
+      }
+      askMessages.push(message);
+    }
+    await appendPendingUserActions(paths, createDirectMessageReplyPendingActions(config.communityAgentId, askMessages));
+  }
+  async function runAutonomousLoopOnce(input = {}) {
+    const config = getActiveConfig(readConfig());
+    if (!config) {
+      throw new Error("community bridge is not active");
+    }
+    const client = new CommunityClient(config);
+    const paths = await ensureWorkspaceForActiveConfig(config);
+    return runAutonomousLoopForConfig(config, client, paths, input);
+  }
+  async function applyProposal(input) {
+    const config = getActiveConfig(readConfig());
+    if (!config) {
+      throw new Error("community bridge is not active");
+    }
+    const subagent = config.communitySubagent;
+    if (!subagent?.enabled || !subagent.agentId || !subagent.workspaceDir) {
+      return {
+        ok: false,
+        reason: "community subagent unavailable",
+        handoffId: input.handoffId
+      };
+    }
+    const client = new CommunityClient(config);
+    const paths = await ensureWorkspaceForActiveConfig(config);
+    const handoffs = await readSubagentHandoffItems(subagent.workspaceDir);
+    const handoff = handoffs.find((item) => item.handoff_id === input.handoffId);
+    if (!handoff) {
+      return {
+        ok: false,
+        reason: "handoff not found",
+        handoffId: input.handoffId,
+        workspaceRootDir: paths.rootDir
+      };
+    }
+    await appendAuditLog(paths, {
+      kind: "subagent.proposal",
+      community_agent_id: config.communityAgentId,
+      action: input.proposal.action,
+      reason: input.proposal.reason ?? "community subagent sidecar proposed action",
+      source_event_id: handoff.handoff_id,
+      envelope_id: handoff.envelope_id,
+      result: "proposed",
+      payload: {
+        handoff_id: handoff.handoff_id,
+        subagent_id: subagent.agentId,
+        risk: input.proposal.action === "dm.reply" ? input.proposal.risk : "medium",
+        proposal: input.proposal,
+        source: "sidecar",
+        ...input.proposalMeta ? { proposal_meta: input.proposalMeta } : {}
+      }
+    });
+    const result = await applySubagentProposal(config, client, paths, handoff, input.proposal, input.proposalMeta);
+    const state = await readSubagentLoopState(paths);
+    const processedIds = new Set(state.processedHandoffIds);
+    processedIds.add(handoff.handoff_id);
+    await writeSubagentLoopState(paths, {
+      version: 1,
+      processedHandoffIds: [...processedIds],
+      lastRunAt: (/* @__PURE__ */ new Date()).toISOString(),
+      lastProcessedHandoffId: handoff.handoff_id
+    });
+    return {
+      ok: true,
+      handoffId: handoff.handoff_id,
+      result,
+      workspaceRootDir: paths.rootDir
+    };
+  }
+  async function runAutonomousLoopForConfig(config, client, paths, input = {}) {
+    const subagent = config.communitySubagent;
+    if (!subagent?.enabled || !subagent.agentId || !subagent.workspaceDir) {
+      return {
+        ok: false,
+        reason: "community subagent unavailable",
+        processed: 0,
+        results: [],
+        workspaceRootDir: paths.rootDir
+      };
+    }
+    const state = await readSubagentLoopState(paths);
+    await writeSubagentLoopState(paths, {
+      version: 1,
+      processedHandoffIds: state.processedHandoffIds,
+      lastRunAt: (/* @__PURE__ */ new Date()).toISOString(),
+      ...state.lastProcessedHandoffId ? { lastProcessedHandoffId: state.lastProcessedHandoffId } : {},
+      lastError: "gateway autonomous loop is disabled; run politeia-loop sidecar instead"
+    });
+    return {
+      ok: false,
+      reason: "gateway autonomous loop is disabled; run politeia-loop sidecar instead",
+      processed: 0,
+      results: [],
+      workspaceRootDir: paths.rootDir
+    };
+  }
+  async function applySubagentProposal(config, client, paths, handoff, proposal, proposalMeta) {
+    if (proposal.action === "meeting.summary") {
+      return applyMeetingSummaryProposal(config, paths, handoff, proposal, proposalMeta);
+    }
+    const dm = readDirectMessageFromHandoff(handoff);
+    if (!dm) {
+      await appendAuditLog(paths, {
+        kind: "subagent.proposal.rejected",
+        community_agent_id: config.communityAgentId,
+        action: proposal.action,
+        decision: "deny",
+        reason: "handoff is not a direct message",
+        source_event_id: handoff.handoff_id,
+        envelope_id: handoff.envelope_id,
+        result: "denied"
+      });
+      return {
+        handoffId: handoff.handoff_id,
+        ok: false,
+        decision: "deny",
+        reason: "handoff is not a direct message"
+      };
+    }
+    if (proposal.risk === "high") {
+      await appendAuditLog(paths, {
+        kind: "subagent.proposal.denied",
+        community_agent_id: config.communityAgentId,
+        action: proposal.action,
+        decision: "deny",
+        reason: "high-risk subagent proposal cannot auto-execute in Phase 2 MVP",
+        source_event_id: handoff.handoff_id,
+        envelope_id: handoff.envelope_id,
+        dm_id: dm.dmId,
+        target_agent_id: dm.senderAgentId,
+        result: "denied",
+        payload: {
+          handoff_id: handoff.handoff_id,
+          draft: proposal.draft,
+          risk: proposal.risk
+        }
+      });
+      await appendAgentActivity(paths, {
+        kind: "subagent.proposal.denied",
+        risk_level: "high",
+        summary: `Community Subagent \u62D2\u7EDD\u81EA\u52A8\u5904\u7406\u6765\u81EA ${dm.senderAgentId} \u7684\u9AD8\u98CE\u9669\u79C1\u4FE1\u3002`,
+        source_agent_id: dm.senderAgentId,
+        target_agent_id: config.communityAgentId,
+        source_event_id: handoff.handoff_id,
+        payload: {
+          inbound_dm_id: dm.dmId,
+          inbound_envelope_id: handoff.envelope_id
+        }
+      });
+      return {
+        handoffId: handoff.handoff_id,
+        ok: true,
+        decision: "deny",
+        risk: proposal.risk
+      };
+    }
+    const policy = await readDelegationPolicy(paths, config.communityAgentId);
+    const gatedAction = proposal.risk === "low" ? "dm.send" : "dm.reply";
+    const policyResult = evaluateDelegationPolicy(policy, { action: gatedAction, risk: proposal.risk });
+    await appendAuditLog(paths, {
+      kind: "policy_decision",
+      community_agent_id: config.communityAgentId,
+      action: gatedAction,
+      decision: policyResult.decision,
+      reason: `subagent proposal risk=${proposal.risk}; matched=${policyResult.matchedRuleId ?? "default"}`,
+      source_event_id: handoff.handoff_id,
+      envelope_id: handoff.envelope_id,
+      dm_id: dm.dmId,
+      target_agent_id: dm.senderAgentId,
+      result: policyResult.decision,
+      payload: {
+        handoff_id: handoff.handoff_id,
+        draft: proposal.draft
+      }
+    });
+    if (policyResult.decision === "allow" && proposal.risk === "low") {
+      const reply = createDirectMessageEnvelope({
+        senderAgentId: config.communityAgentId,
+        targetAgentId: dm.senderAgentId,
+        message: proposal.draft,
+        intent: "agentcomm.subagent.dm_reply"
+      });
+      const publishResult = await client.publishEnvelope(reply);
+      await appendWorkspaceEnvelope(paths, config.communityAgentId, reply);
+      await appendAuditLog(paths, {
+        kind: "subagent.dm.reply.sent",
+        community_agent_id: config.communityAgentId,
+        action: "dm.send",
+        decision: "allow",
+        reason: `subagent low-risk reply; matched=${policyResult.matchedRuleId ?? "default"}`,
+        source_event_id: handoff.handoff_id,
+        envelope_id: reply.envelope_id,
+        dm_id: publishResult.dm_id,
+        target_agent_id: dm.senderAgentId,
+        result: "sent",
+        payload: {
+          inbound_dm_id: dm.dmId,
+          inbound_envelope_id: handoff.envelope_id
+        }
+      });
+      await appendAgentActivity(paths, {
+        kind: "subagent.dm.reply.sent",
+        risk_level: "low",
+        summary: `Community Subagent \u5DF2\u81EA\u52A8\u56DE\u590D ${dm.senderAgentId}\u3002`,
+        source_agent_id: dm.senderAgentId,
+        target_agent_id: config.communityAgentId,
+        source_event_id: handoff.handoff_id,
+        payload: {
+          reply_envelope_id: reply.envelope_id,
+          matched_rule_id: policyResult.matchedRuleId
+        }
+      });
+      return {
+        handoffId: handoff.handoff_id,
+        ok: true,
+        decision: "allow",
+        action: "dm.send",
+        envelopeId: reply.envelope_id,
+        dmId: publishResult.dm_id ?? null
+      };
+    }
+    if (policyResult.decision === "ask") {
+      const pendingAction = createSubagentReplyPendingAction(config.communityAgentId, handoff, dm, proposal);
+      await appendPendingUserActions(paths, [pendingAction]);
+      await appendAgentActivity(paths, {
+        kind: "subagent.dm.reply.pending",
+        risk_level: proposal.risk,
+        summary: `Community Subagent \u5DF2\u4E3A ${dm.senderAgentId} \u8D77\u8349\u56DE\u590D\uFF0C\u7B49\u5F85\u7528\u6237\u786E\u8BA4\u3002`,
+        source_agent_id: dm.senderAgentId,
+        target_agent_id: config.communityAgentId,
+        source_event_id: handoff.handoff_id,
+        payload: {
+          action_id: pendingAction.action_id,
+          matched_rule_id: policyResult.matchedRuleId
+        }
+      });
+      return {
+        handoffId: handoff.handoff_id,
+        ok: true,
+        decision: "ask",
+        actionId: pendingAction.action_id
+      };
+    }
+    await appendAuditLog(paths, {
+      kind: "subagent.proposal.denied",
+      community_agent_id: config.communityAgentId,
+      action: gatedAction,
+      decision: "deny",
+      reason: `subagent proposal blocked by policy; matched=${policyResult.matchedRuleId ?? "default"}`,
+      source_event_id: handoff.handoff_id,
+      envelope_id: handoff.envelope_id,
+      dm_id: dm.dmId,
+      target_agent_id: dm.senderAgentId,
+      result: "denied",
+      payload: {
+        handoff_id: handoff.handoff_id,
+        draft: proposal.draft
+      }
+    });
+    return {
+      handoffId: handoff.handoff_id,
+      ok: true,
+      decision: "deny"
+    };
+  }
+  async function applyMeetingSummaryProposal(config, paths, handoff, proposal, proposalMeta) {
+    const roomId = readString3(handoff.payload.room_id);
+    if (handoff.kind !== "meeting_summary" || !roomId || roomId !== proposal.room_id) {
+      await appendAuditLog(paths, {
+        kind: "subagent.proposal.rejected",
+        community_agent_id: config.communityAgentId,
+        action: proposal.action,
+        decision: "deny",
+        reason: "handoff is not a matching meeting summary request",
+        source_event_id: handoff.handoff_id,
+        envelope_id: handoff.envelope_id,
+        result: "denied",
+        payload: {
+          handoff_room_id: roomId ?? null,
+          proposal_room_id: proposal.room_id
+        }
+      });
+      return {
+        handoffId: handoff.handoff_id,
+        ok: false,
+        decision: "deny",
+        reason: "handoff is not a matching meeting summary request"
+      };
+    }
+    const policy = await readDelegationPolicy(paths, config.communityAgentId);
+    const policyResult = evaluateDelegationPolicy(policy, { action: "meeting.summary", risk: "medium" });
+    await appendAuditLog(paths, {
+      kind: "policy_decision",
+      community_agent_id: config.communityAgentId,
+      action: "meeting.summary",
+      decision: policyResult.decision,
+      reason: `meeting summary proposal; matched=${policyResult.matchedRuleId ?? "default"}`,
+      source_event_id: handoff.handoff_id,
+      envelope_id: handoff.envelope_id,
+      result: policyResult.decision,
+      payload: {
+        handoff_id: handoff.handoff_id,
+        room_id: proposal.room_id,
+        summary: proposal.summary,
+        todos: proposal.todos
+      }
+    });
+    if (policyResult.decision !== "ask") {
+      await appendAuditLog(paths, {
+        kind: "meeting.summary.blocked",
+        community_agent_id: config.communityAgentId,
+        action: "meeting.summary",
+        decision: policyResult.decision,
+        reason: "meeting summaries must be user-confirmed in v1",
+        source_event_id: handoff.handoff_id,
+        envelope_id: handoff.envelope_id,
+        result: "blocked"
+      });
+      return {
+        handoffId: handoff.handoff_id,
+        ok: true,
+        decision: "deny",
+        reason: "meeting summaries must be user-confirmed in v1"
+      };
+    }
+    const pendingAction = createMeetingSummaryPendingAction(config.communityAgentId, handoff, proposal, proposalMeta);
+    await appendPendingUserActions(paths, [pendingAction]);
+    await appendAgentActivity(paths, {
+      kind: "meeting.summary.pending",
+      risk_level: "medium",
+      summary: `Community Subagent \u5DF2\u4E3A\u4F1A\u8BAE\u623F\u95F4 ${proposal.room_id} \u751F\u6210\u6458\u8981\u548C\u5F85\u529E\uFF0C\u7B49\u5F85\u7528\u6237\u786E\u8BA4\u3002`,
+      source_event_id: handoff.handoff_id,
+      payload: {
+        action_id: pendingAction.action_id,
+        room_id: proposal.room_id,
+        matched_rule_id: policyResult.matchedRuleId
+      }
+    });
+    return {
+      handoffId: handoff.handoff_id,
+      ok: true,
+      decision: "ask",
+      actionId: pendingAction.action_id,
+      roomId: proposal.room_id
+    };
+  }
+  async function handleInboundRoutedEnvelopes(config, client, paths, items) {
+    for (const item of items) {
+      const envelope = item.envelope;
+      if (isRoomCreatedEnvelope(envelope)) {
+        await upsertRoom(paths, envelope.payload.room);
+        await appendAuditLog(paths, {
+          kind: "room.created.received",
+          community_agent_id: config.communityAgentId,
+          action: "room.created",
+          decision: "allow",
+          reason: "room membership routed by platform",
+          source_event_id: item.delivery_id,
+          envelope_id: item.envelope_id,
+          target_agent_id: item.sender_agent_id,
+          result: "stored",
+          payload: {
+            room_id: envelope.payload.room.room_id,
+            members: envelope.payload.room.members,
+            source_negotiation_id: envelope.payload.room.source_negotiation_id ?? null
+          }
+        });
+        continue;
+      }
+      if (isRoomMessageEnvelope(envelope)) {
+        const roomId = envelope.target.room_id;
+        await appendRoomMessages(paths, [createRoomMessageRecord(envelope, item.delivery_id)]);
+        await appendAuditLog(paths, {
+          kind: "room.message.received",
+          community_agent_id: config.communityAgentId,
+          action: "room.message.receive",
+          decision: "allow",
+          reason: "room message stored as local transcript; v1 agent remains observer-only",
+          source_event_id: item.delivery_id,
+          envelope_id: item.envelope_id,
+          target_agent_id: item.sender_agent_id,
+          result: "stored",
+          payload: {
+            room_id: roomId,
+            speaker_kind: envelope.payload.speaker_kind
+          }
+        });
+        continue;
+      }
+      if (!isScheduleNegotiateEnvelope(envelope)) {
+        await appendAuditLog(paths, {
+          kind: "envelope.received",
+          community_agent_id: config.communityAgentId,
+          action: `envelope.${item.type}`,
+          decision: "allow",
+          reason: "routed envelope stored without semantic handling",
+          source_event_id: item.delivery_id,
+          envelope_id: item.envelope_id,
+          target_agent_id: item.sender_agent_id,
+          result: "stored"
+        });
+        continue;
+      }
+      await handleScheduleEnvelope(config, client, paths, envelope, item.delivery_id);
+    }
+  }
+  function isRoomCreatedEnvelope(envelope) {
+    return envelope.type === "room.created" && isRoomRecord(envelope.payload.room);
+  }
+  function isRoomMessageEnvelope(envelope) {
+    return envelope.type === "room.message" && envelope.target.kind === "room" && typeof envelope.target.room_id === "string" && typeof envelope.payload.message === "string" && (envelope.payload.speaker_kind === "human" || envelope.payload.speaker_kind === "agent");
+  }
+  function createRoomMessageRecord(envelope, deliveryId, messageId) {
+    return {
+      ...messageId ? { message_id: messageId } : {},
+      ...deliveryId ? { delivery_id: deliveryId } : {},
+      room_id: envelope.target.kind === "room" ? envelope.target.room_id : "",
+      envelope_id: envelope.envelope_id,
+      sender_agent_id: envelope.sender_agent_id,
+      speaker_kind: envelope.payload.speaker_kind,
+      speaker_label: envelope.payload.speaker_label ?? null,
+      message: envelope.payload.message,
+      intent: envelope.payload.intent ?? null,
+      created_at: envelope.created_at
+    };
+  }
+  function isRoomRecord(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value) && typeof value.room_id === "string" && typeof value.topic === "string" && Array.isArray(value.members) && typeof value.created_by_agent_id === "string";
+  }
+  async function handleScheduleEnvelope(config, client, paths, envelope, deliveryId) {
+    const { policy, risk, policyResult } = await evaluateSchedulePolicy(paths, config.communityAgentId, envelope.payload.kind);
+    await appendAuditLog(paths, {
+      kind: "policy_decision",
+      community_agent_id: config.communityAgentId,
+      action: `schedule.negotiate.${envelope.payload.kind}`,
+      decision: policyResult.decision,
+      reason: `inbound schedule negotiation risk=${risk}; matched=${policyResult.matchedRuleId ?? "default"}`,
+      source_event_id: deliveryId,
+      envelope_id: envelope.envelope_id,
+      target_agent_id: envelope.sender_agent_id,
+      result: policyResult.decision,
+      payload: {
+        negotiation_id: envelope.payload.negotiation_id,
+        acting_for: envelope.acting_for ?? envelope.sender_agent_id
+      }
+    });
+    if (envelope.payload.kind === "commit") {
+      await writeScheduleState(
+        paths,
+        updateScheduleState(
+          await readScheduleState(paths),
+          createScheduleStateFromEnvelope(envelope, "committed", envelope.payload.candidate_windows, envelope.payload.selected_window)
+        )
+      );
+      await appendAuditLog(paths, {
+        kind: "schedule.commit.received",
+        community_agent_id: config.communityAgentId,
+        action: "schedule.negotiate.commit",
+        decision: "ask",
+        reason: "peer committed; local commitment still requires local user confirmation",
+        source_event_id: deliveryId,
+        envelope_id: envelope.envelope_id,
+        target_agent_id: envelope.sender_agent_id,
+        result: "received",
+        payload: {
+          negotiation_id: envelope.payload.negotiation_id,
+          selected_window: envelope.payload.selected_window ?? null
+        }
+      });
+      return;
+    }
+    if (policyResult.decision !== "allow") {
+      return;
+    }
+    if (envelope.payload.kind === "decline") {
+      await writeScheduleState(
+        paths,
+        updateScheduleState(
+          await readScheduleState(paths),
+          createScheduleStateFromEnvelope(envelope, "declined", envelope.payload.candidate_windows)
+        )
+      );
+      return;
+    }
+    if (envelope.payload.kind === "agree_pending") {
+      const selectedWindow2 = envelope.payload.selected_window ?? envelope.payload.candidate_windows[0];
+      await writeScheduleState(
+        paths,
+        updateScheduleState(
+          await readScheduleState(paths),
+          createScheduleStateFromEnvelope(envelope, "agree_pending", envelope.payload.candidate_windows, selectedWindow2)
+        )
+      );
+      await appendAuditLog(paths, {
+        kind: "schedule.agree_pending.received",
+        community_agent_id: config.communityAgentId,
+        action: "schedule.negotiate.agree_pending",
+        decision: "ask",
+        reason: "peer proposed a final meeting window; local commit requires user confirmation",
+        source_event_id: deliveryId,
+        envelope_id: envelope.envelope_id,
+        target_agent_id: envelope.sender_agent_id,
+        result: selectedWindow2 ? "pending_user_confirmation" : "missing_selected_window",
+        payload: {
+          negotiation_id: envelope.payload.negotiation_id,
+          selected_window: selectedWindow2 ?? null
+        }
+      });
+      if (selectedWindow2) {
+        await appendPendingUserActions(paths, [
+          createScheduleCommitPendingAction(config.communityAgentId, envelope, selectedWindow2)
+        ]);
+      }
+      return;
+    }
+    if (envelope.payload.kind !== "propose" && envelope.payload.kind !== "counter") {
+      return;
+    }
+    const intersections = intersectScheduleWindows(
+      envelope.payload.candidate_windows,
+      getSchedulingAvailableWindows(policy),
+      envelope.payload.duration_minutes
+    );
+    const nextKind = intersections.length === 0 ? "decline" : intersections.length === 1 ? "agree_pending" : "counter";
+    const selectedWindow = intersections.length === 1 ? intersections[0] : void 0;
+    const reply = createScheduleNegotiateEnvelope({
+      senderAgentId: config.communityAgentId,
+      targetAgentId: envelope.sender_agent_id,
+      actingFor: policy.principal.userId,
+      kind: nextKind,
+      negotiationId: envelope.payload.negotiation_id,
+      topic: envelope.payload.topic,
+      durationMinutes: envelope.payload.duration_minutes,
+      candidateWindows: intersections,
+      selectedWindow,
+      reason: intersections.length === 0 ? "no-overlap" : void 0
+    });
+    const publishResult = await client.publishEnvelope(reply);
+    await appendWorkspaceEnvelope(paths, config.communityAgentId, reply);
+    await appendAuditLog(paths, {
+      kind: "schedule.negotiate",
+      community_agent_id: config.communityAgentId,
+      action: `schedule.negotiate.${nextKind}`,
+      decision: "allow",
+      reason: `deterministic intersection produced ${intersections.length} candidate(s)`,
+      source_event_id: envelope.envelope_id,
+      envelope_id: reply.envelope_id,
+      target_agent_id: envelope.sender_agent_id,
+      result: "sent",
+      payload: {
+        negotiation_id: reply.payload.negotiation_id,
+        candidate_windows: intersections,
+        delivery_id: publishResult.dm_id ?? null
+      }
+    });
+    await writeScheduleState(
+      paths,
+      updateScheduleState(
+        await readScheduleState(paths),
+        createScheduleStateFromEnvelope(
+          reply,
+          nextKind === "decline" ? "declined" : nextKind === "counter" ? "countered" : "agree_pending",
+          intersections,
+          selectedWindow,
+          { peerAgentId: envelope.sender_agent_id }
+        )
+      )
+    );
+    if (selectedWindow) {
+      await appendPendingUserActions(paths, [
+        createScheduleCommitPendingAction(config.communityAgentId, reply, selectedWindow, {
+          peerAgentId: envelope.sender_agent_id,
+          inboundEnvelopeId: envelope.envelope_id
+        })
+      ]);
+    }
+  }
+  async function createRoomForScheduleCommit(config, paths, input) {
+    const client = new CommunityClient(config);
+    const response = await client.createRoom({
+      topic: input.topic,
+      members: [config.communityAgentId, input.peerAgentId],
+      sourceNegotiationId: input.negotiationId
+    });
+    await upsertRoom(paths, response.room);
+    await appendAuditLog(paths, {
+      kind: "room.created",
+      community_agent_id: config.communityAgentId,
+      action: "room.create",
+      decision: "allow",
+      reason: response.existing ? "schedule commit resolved to existing room" : "schedule commit created meeting room",
+      envelope_id: response.envelope_id,
+      target_agent_id: input.peerAgentId,
+      result: response.existing ? "existing" : "created",
+      payload: {
+        room_id: response.room.room_id,
+        topic: response.room.topic,
+        members: response.room.members,
+        source_negotiation_id: input.negotiationId
+      }
+    });
+    return response.room;
+  }
+  async function buildInboxSummary(paths) {
+    const [inbox, sentDms, pendingActions, decisions, results] = await Promise.all([
+      readReceivedDirectMessages(paths),
+      readSentDirectMessages(paths),
+      readPendingUserActions(paths),
+      readUserActionDecisions(paths),
+      readUserActionResults(paths)
+    ]);
+    const decidedActionIds = new Set(decisions.map((decision) => decision.action_id));
+    const resultActionIds = new Set(results.map((result) => result.action_id));
+    const openPendingActions = pendingActions.filter(
+      (action) => !decidedActionIds.has(action.action_id) && !resultActionIds.has(action.action_id)
+    );
+    return {
+      ok: true,
+      workspaceRootDir: paths.rootDir,
+      inboxCount: inbox.length,
+      sentDmCount: sentDms.length,
+      pendingDecisionCount: openPendingActions.length,
+      latestMessages: inbox.slice(-10).map((message) => ({
+        dm_id: message.dm_id,
+        from: message.sender_agent_id,
+        message: message.message,
+        intent: message.intent ?? null,
+        created_at: message.created_at
+      })),
+      pendingDecisions: openPendingActions.slice(-10).map((action) => ({
+        action_id: action.action_id,
+        kind: action.kind,
+        title: action.title,
+        summary: action.summary,
+        created_at: action.created_at,
+        payload: action.payload
+      }))
+    };
+  }
+  async function pollOnce() {
+    const config = getActiveConfig(readConfig());
+    if (!config) {
+      status = { ...status, enabled: false, connected: false, running };
+      return status;
+    }
+    try {
+      const client = new CommunityClient(config);
+      const paths = await ensureWorkspaceForActiveConfig(config);
+      const workspaceState = paths ? await readPlatformWorkspaceState(paths) : null;
+      const inboxCursor = workspaceState?.lastInboxCursor;
+      const skillOfferCursor = workspaceState?.lastSkillOfferCursor;
+      const envelopeCursor = workspaceState?.lastEnvelopeCursor;
+      const keepalive = await client.sendKeepalive(inboxCursor, skillOfferCursor, envelopeCursor);
+      const keepaliveAt = (/* @__PURE__ */ new Date()).toISOString();
+      if (paths) {
+        await markWorkspaceKeepalive(paths, config.communityAgentId, keepaliveAt);
+      }
+      const shouldRunLegacyHeartbeat = config.acceptanceDemo?.enabled === true;
+      const tick = shouldRunLegacyHeartbeat ? await client.fetchNextHeartbeat() : null;
+      status = {
+        enabled: true,
+        connected: true,
+        running,
+        communityAgentId: config.communityAgentId,
+        ...paths ? { workspaceRootDir: paths.rootDir } : {},
+        lastKeepaliveAt: keepaliveAt,
+        lastPollAt: keepaliveAt,
+        ...inboxCursor ? { lastInboxCursor: inboxCursor } : {},
+        ...tick ? { lastTickId: tick.tick_id } : {}
+      };
+      const pendingDirectMessages = keepalive.pending_direct_messages ?? keepalive.pending_count ?? 0;
+      if (paths && pendingDirectMessages > 0) {
+        const inbox = await client.fetchDirectMessages(inboxCursor);
+        await appendReceivedDirectMessages(paths, config.communityAgentId, inbox.items, inbox.next_cursor);
+        await appendSubagentHandoffItems(
+          config.communitySubagent?.workspaceDir,
+          config.communityAgentId,
+          createDirectMessageHandoffItems(config.communityAgentId, inbox.items)
+        );
+        await handleInboundDirectMessages(config, client, paths, inbox.items);
+        status = {
+          ...status,
+          ...inbox.next_cursor ? { lastInboxCursor: inbox.next_cursor } : {},
+          lastInboxSyncAt: (/* @__PURE__ */ new Date()).toISOString()
+        };
+      }
+      const pendingEnvelopes = keepalive.pending_envelopes ?? 0;
+      if (paths && pendingEnvelopes > 0) {
+        const envelopeInbox = await client.fetchEnvelopes(envelopeCursor);
+        await appendReceivedEnvelopes(paths, config.communityAgentId, envelopeInbox.items, envelopeInbox.next_cursor);
+        await handleInboundRoutedEnvelopes(config, client, paths, envelopeInbox.items);
+        status = {
+          ...status,
+          lastPollAt: (/* @__PURE__ */ new Date()).toISOString()
+        };
+      }
+      const pendingSkillOffers = keepalive.pending_skill_offers ?? 0;
+      if (paths && pendingSkillOffers > 0) {
+        const skillOffers = await client.fetchSkillOffers(skillOfferCursor);
+        await appendStagedSkillOffers(paths, config.communityAgentId, skillOffers.items, skillOffers.next_cursor);
+        await appendPendingUserActions(
+          paths,
+          createSkillOfferPendingActions(config.communityAgentId, skillOffers.items)
+        );
+        await appendSubagentHandoffItems(
+          config.communitySubagent?.workspaceDir,
+          config.communityAgentId,
+          createSkillOfferHandoffItems(config.communityAgentId, skillOffers.items)
+        );
+        status = {
+          ...status,
+          lastSkillOfferSyncAt: (/* @__PURE__ */ new Date()).toISOString()
+        };
+      }
+      if (paths && config.autonomousLoop?.enabled === true) {
+        const loopResult = await runAutonomousLoopForConfig(config, client, paths, {
+          maxItems: config.autonomousLoop.maxItemsPerPoll ?? 1
+        });
+        status = {
+          ...status,
+          lastAutonomousLoopAt: (/* @__PURE__ */ new Date()).toISOString(),
+          lastAutonomousLoopProcessed: loopResult.processed
+        };
+      }
+      if (tick) {
+        await client.submitIntent(createIntentFromTick(tick));
+      }
+    } catch (error) {
+      status = {
+        enabled: true,
+        connected: false,
+        running,
+        communityAgentId: config.communityAgentId,
+        lastPollAt: (/* @__PURE__ */ new Date()).toISOString(),
+        lastError: error instanceof Error ? error.message : "unknown error"
+      };
+    }
+    return status;
+  }
+  async function start() {
+    if (running) {
+      return;
+    }
+    running = true;
+    status = { ...status, running: true };
+    await pollOnce();
+    const config = getActiveConfig(readConfig());
+    if (config) {
+      timer = setInterval(() => {
+        void pollOnce();
+      }, config.pollIntervalMs);
+    }
+  }
+  async function stop() {
+    if (timer) {
+      clearInterval(timer);
+      timer = void 0;
+    }
+    running = false;
+    status = { ...status, running: false };
+  }
+  return {
+    start,
+    stop,
+    pollOnce,
+    runAutonomousLoopOnce,
+    applyProposal,
+    listAgents: async () => {
+      const config = getActiveConfig(readConfig());
+      if (!config) {
+        throw new Error("community bridge is not active");
+      }
+      const client = new CommunityClient(config);
+      return client.listAgents();
+    },
+    checkInbox: async () => {
+      const config = getActiveConfig(readConfig());
+      if (!config) {
+        throw new Error("community bridge is not active");
+      }
+      const paths = await ensureWorkspaceForActiveConfig(config);
+      return buildInboxSummary(paths);
+    },
+    postPublish: async (input) => {
+      const config = getActiveConfig(readConfig());
+      if (!config) {
+        throw new Error("community bridge is not active");
+      }
+      const client = new CommunityClient(config);
+      const envelope = createPostPublishEnvelope({
+        senderAgentId: config.communityAgentId,
+        title: input.title,
+        body: input.body,
+        intent: input.intent,
+        tags: input.tags
+      });
+      await client.publishEnvelope(envelope);
+      const paths = await ensureWorkspaceForActiveConfig(config);
+      if (paths) {
+        await appendWorkspaceEnvelope(paths, config.communityAgentId, envelope);
+      }
+      return {
+        ok: true,
+        envelopeId: envelope.envelope_id,
+        ...paths ? { workspaceRootDir: paths.rootDir } : {}
+      };
+    },
+    dmSend: async (input) => {
+      const config = getActiveConfig(readConfig());
+      if (!config) {
+        throw new Error("community bridge is not active");
+      }
+      const client = new CommunityClient(config);
+      const paths = await ensureWorkspaceForActiveConfig(config);
+      const envelope = createDirectMessageEnvelope({
+        senderAgentId: config.communityAgentId,
+        targetAgentId: input.targetAgentId,
+        message: input.message,
+        intent: input.intent
+      });
+      const policyResult = await evaluateOutboundDmPolicy(
+        paths,
+        config.communityAgentId,
+        input.targetAgentId,
+        envelope.envelope_id
+      );
+      if (policyResult.decision !== "allow") {
+        throw new Error(`dm.send blocked by delegation policy: ${policyResult.decision}`);
+      }
+      const publishResult = await client.publishEnvelope(envelope);
+      if (paths) {
+        await appendWorkspaceEnvelope(paths, config.communityAgentId, envelope);
+        await appendAuditLog(paths, {
+          kind: "policy_decision",
+          community_agent_id: config.communityAgentId,
+          action: "dm.send",
+          decision: policyResult.decision,
+          reason: `target=${input.targetAgentId}; matched=${policyResult.matchedRuleId ?? "default"}`,
+          envelope_id: envelope.envelope_id,
+          dm_id: publishResult.dm_id,
+          source_event_id: envelope.envelope_id,
+          target_agent_id: input.targetAgentId,
+          result: "allowed"
+        });
+        await appendAuditLog(paths, {
+          kind: "dm.send",
+          community_agent_id: config.communityAgentId,
+          action: "dm.send",
+          decision: "allow",
+          reason: `matched ${policyResult.matchedRuleId ?? "default"}`,
+          envelope_id: envelope.envelope_id,
+          dm_id: publishResult.dm_id,
+          source_event_id: envelope.envelope_id,
+          target_agent_id: input.targetAgentId,
+          result: "sent",
+          payload: {
+            intent: input.intent ?? null
+          }
+        });
+      }
+      return {
+        ok: true,
+        envelopeId: envelope.envelope_id,
+        ...paths ? { workspaceRootDir: paths.rootDir } : {}
+      };
+    },
+    schedulePropose: async (input) => {
+      const config = getActiveConfig(readConfig());
+      if (!config) {
+        throw new Error("community bridge is not active");
+      }
+      const client = new CommunityClient(config);
+      const paths = await ensureWorkspaceForActiveConfig(config);
+      const { policy, policyResult } = await evaluateSchedulePolicy(paths, config.communityAgentId, "propose");
+      if (policyResult.decision !== "allow") {
+        throw new Error(`schedule.negotiate.propose blocked by delegation policy: ${policyResult.decision}`);
+      }
+      const envelope = createScheduleNegotiateEnvelope({
+        senderAgentId: config.communityAgentId,
+        targetAgentId: input.targetAgentId,
+        actingFor: input.actingFor ?? policy.principal.userId,
+        kind: "propose",
+        topic: input.topic,
+        durationMinutes: input.durationMinutes,
+        candidateWindows: input.candidateWindows
+      });
+      const publishResult = await client.publishEnvelope(envelope);
+      await appendWorkspaceEnvelope(paths, config.communityAgentId, envelope);
+      await appendAuditLog(paths, {
+        kind: "policy_decision",
+        community_agent_id: config.communityAgentId,
+        action: "schedule.negotiate.propose",
+        decision: policyResult.decision,
+        reason: `target=${input.targetAgentId}; matched=${policyResult.matchedRuleId ?? "default"}`,
+        envelope_id: envelope.envelope_id,
+        source_event_id: envelope.envelope_id,
+        target_agent_id: input.targetAgentId,
+        result: "allowed",
+        payload: {
+          negotiation_id: envelope.payload.negotiation_id,
+          acting_for: envelope.acting_for
+        }
+      });
+      await appendAuditLog(paths, {
+        kind: "schedule.negotiate",
+        community_agent_id: config.communityAgentId,
+        action: "schedule.negotiate.propose",
+        decision: "allow",
+        reason: "outbound schedule proposal",
+        envelope_id: envelope.envelope_id,
+        source_event_id: envelope.envelope_id,
+        target_agent_id: input.targetAgentId,
+        result: "sent",
+        payload: {
+          negotiation_id: envelope.payload.negotiation_id,
+          candidate_windows: envelope.payload.candidate_windows,
+          delivery_id: publishResult.dm_id ?? null
+        }
+      });
+      await writeScheduleState(
+        paths,
+        updateScheduleState(
+          await readScheduleState(paths),
+          createScheduleStateFromEnvelope(envelope, "proposed", envelope.payload.candidate_windows, void 0, {
+            peerAgentId: input.targetAgentId
+          })
+        )
+      );
+      return {
+        ok: true,
+        envelopeId: envelope.envelope_id,
+        negotiationId: envelope.payload.negotiation_id,
+        workspaceRootDir: paths.rootDir
+      };
+    },
+    prepareMeetingSummary: async (input) => {
+      const config = getActiveConfig(readConfig());
+      if (!config) {
+        throw new Error("community bridge is not active");
+      }
+      const subagent = config.communitySubagent;
+      if (!subagent?.enabled || !subagent.workspaceDir) {
+        throw new Error("community subagent workspace is unavailable");
+      }
+      const paths = await ensureWorkspaceForActiveConfig(config);
+      const room = (await readRooms(paths)).find((item) => item.room_id === input.roomId);
+      if (!room) {
+        throw new Error(`room not found in local workspace: ${input.roomId}`);
+      }
+      const messages = await readRoomMessages(paths, input.roomId);
+      if (messages.length === 0) {
+        throw new Error(`room transcript is empty: ${input.roomId}`);
+      }
+      const now = /* @__PURE__ */ new Date();
+      const policy = await readDelegationPolicy(paths, config.communityAgentId);
+      const timezone = policy.scheduling?.timezone ?? Intl.DateTimeFormat().resolvedOptions().timeZone;
+      const handoff = createMeetingSummaryHandoffItem(config.communityAgentId, {
+        room,
+        messages,
+        timezone,
+        currentDate: formatDateForTimeZone(now, timezone),
+        currentTime: now.toISOString()
+      });
+      const writeResult = await appendSubagentHandoffItems(subagent.workspaceDir, config.communityAgentId, [handoff]);
+      await appendAuditLog(paths, {
+        kind: "meeting.summary.requested",
+        community_agent_id: config.communityAgentId,
+        action: "meeting.summary",
+        decision: "ask",
+        reason: "manual meeting summary requested; sidecar will call community subagent",
+        source_event_id: handoff.handoff_id,
+        envelope_id: handoff.envelope_id,
+        result: "handoff_created",
+        payload: {
+          room_id: input.roomId,
+          message_count: messages.length,
+          timezone,
+          current_date: handoff.payload.current_date,
+          current_time: handoff.payload.current_time,
+          subagent_handoff: writeResult
+        }
+      });
+      return {
+        ok: true,
+        roomId: input.roomId,
+        handoffId: handoff.handoff_id,
+        workspaceRootDir: paths.rootDir,
+        subagentWorkspaceDir: subagent.workspaceDir
+      };
+    },
+    roomSend: async (input) => {
+      const config = getActiveConfig(readConfig());
+      if (!config) {
+        throw new Error("community bridge is not active");
+      }
+      const paths = await ensureWorkspaceForActiveConfig(config);
+      const policy = await readDelegationPolicy(paths, config.communityAgentId);
+      const policyResult = evaluateDelegationPolicy(policy, { action: "room.message.send", risk: "low" });
+      if (policyResult.decision !== "allow") {
+        throw new Error(`room.message.send blocked by delegation policy: ${policyResult.decision}`);
+      }
+      const room = (await readRooms(paths)).find((item) => item.room_id === input.roomId);
+      if (!room) {
+        throw new Error(`room not found in local workspace: ${input.roomId}`);
+      }
+      if (!room.members.includes(config.communityAgentId)) {
+        throw new Error(`local agent is not a room member: ${input.roomId}`);
+      }
+      const envelope = createRoomMessageEnvelope({
+        senderAgentId: config.communityAgentId,
+        roomId: input.roomId,
+        message: input.message,
+        speakerKind: input.speakerKind ?? "human",
+        speakerLabel: input.speakerLabel ?? policy.principal.userId,
+        intent: input.intent
+      });
+      const publishResult = await new CommunityClient(config).publishEnvelope(envelope);
+      await appendWorkspaceEnvelope(paths, config.communityAgentId, envelope);
+      await appendRoomMessages(paths, [createRoomMessageRecord(envelope, void 0, publishResult.message_id)]);
+      await appendAuditLog(paths, {
+        kind: "room.message.sent",
+        community_agent_id: config.communityAgentId,
+        action: "room.message.send",
+        decision: "allow",
+        reason: `matched ${policyResult.matchedRuleId ?? "default"}`,
+        envelope_id: envelope.envelope_id,
+        source_event_id: envelope.envelope_id,
+        result: "sent",
+        payload: {
+          room_id: input.roomId,
+          message_id: publishResult.message_id ?? null,
+          speaker_kind: envelope.payload.speaker_kind,
+          delivery_ids: publishResult.delivery_ids ?? []
+        }
+      });
+      return {
+        ok: true,
+        envelopeId: envelope.envelope_id,
+        roomId: input.roomId,
+        messageId: publishResult.message_id,
+        workspaceRootDir: paths.rootDir
+      };
+    },
+    skillQuery: async (input) => {
+      const config = getActiveConfig(readConfig());
+      if (!config) {
+        throw new Error("community bridge is not active");
+      }
+      const client = new CommunityClient(config);
+      const envelope = createSkillQueryEnvelope({
+        senderAgentId: config.communityAgentId,
+        need: input.need,
+        context: input.context,
+        intent: input.intent,
+        tags: input.tags
+      });
+      await client.publishEnvelope(envelope);
+      const paths = await ensureWorkspaceForActiveConfig(config);
+      let stagedOffers = 0;
+      if (paths) {
+        await appendWorkspaceEnvelope(paths, config.communityAgentId, envelope);
+        const workspaceState = await readPlatformWorkspaceState(paths);
+        const skillOffers = await client.fetchSkillOffers(workspaceState?.lastSkillOfferCursor);
+        await appendStagedSkillOffers(paths, config.communityAgentId, skillOffers.items, skillOffers.next_cursor);
+        await appendPendingUserActions(
+          paths,
+          createSkillOfferPendingActions(config.communityAgentId, skillOffers.items)
+        );
+        await appendSubagentHandoffItems(
+          config.communitySubagent?.workspaceDir,
+          config.communityAgentId,
+          createSkillOfferHandoffItems(config.communityAgentId, skillOffers.items)
+        );
+        stagedOffers = skillOffers.items.length;
+      }
+      return {
+        ok: true,
+        envelopeId: envelope.envelope_id,
+        stagedOffers,
+        ...paths ? { workspaceRootDir: paths.rootDir } : {}
+      };
+    },
+    skillInstall: async (input) => {
+      const config = getActiveConfig(readConfig());
+      if (!config) {
+        throw new Error("community bridge is not active");
+      }
+      const target = input.offerId ?? input.skillSlug;
+      if (!target || target.trim().length === 0) {
+        throw new Error("offerId or skillSlug is required");
+      }
+      const paths = await ensureWorkspaceForActiveConfig(config);
+      const offers = await readStagedSkillOffers(paths);
+      const offer = offers.find((item) => item.offer_id === target || item.skill_slug === target);
+      if (!offer) {
+        throw new Error(`no staged skill offer matched ${target}`);
+      }
+      if (offer.status !== "pending_user_confirmation" && offer.status !== "accepted") {
+        throw new Error(`skill offer is not installable yet: status=${offer.status}`);
+      }
+      const installingOffer = attachSkillInstallMetadata(offer, {
+        status: "installing",
+        install_method: "pending_user_side_installer",
+        install_agent: input.agentId ?? "main",
+        install_started_at: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      await writeStagedSkillOffer(paths, installingOffer);
+      const result = installOpenClawSkill(offer.skill_slug);
+      const nextOffer = attachSkillInstallMetadata(offer, {
+        status: result.ok ? "installed" : "install_failed",
+        install_status: result.ok ? "passed" : "failed",
+        install_method: "pending_user_side_installer",
+        install_agent: input.agentId ?? "main",
+        install_checked_at: (/* @__PURE__ */ new Date()).toISOString(),
+        install_result: result
+      });
+      await writeStagedSkillOffer(paths, nextOffer);
+      return {
+        ok: result.ok,
+        offerId: nextOffer.offer_id,
+        skillSlug: nextOffer.skill_slug,
+        status: nextOffer.status,
+        installAgent: commandContext.agentId,
+        installHome: commandContext.homeDir,
+        installCwd: commandContext.cwd,
+        stdout: result.stdout,
+        stderr: result.stderr,
+        workspaceRootDir: paths.rootDir
+      };
+    },
+    confirmAction: async (input) => {
+      const config = getActiveConfig(readConfig());
+      if (!config) {
+        throw new Error("community bridge is not active");
+      }
+      const paths = await ensureWorkspaceForActiveConfig(config);
+      return decidePendingUserAction(paths, {
+        actionId: input.actionId,
+        decision: "accepted",
+        decidedBy: input.decidedBy ?? "bridge",
+        reason: input.reason
+      });
+    },
+    rejectAction: async (input) => {
+      const config = getActiveConfig(readConfig());
+      if (!config) {
+        throw new Error("community bridge is not active");
+      }
+      const paths = await ensureWorkspaceForActiveConfig(config);
+      return decidePendingUserAction(paths, {
+        actionId: input.actionId,
+        decision: "rejected",
+        decidedBy: input.decidedBy ?? "bridge",
+        reason: input.reason
+      });
+    },
+    applyAcceptedAction: async (input) => {
+      const config = getActiveConfig(readConfig());
+      if (!config) {
+        throw new Error("community bridge is not active");
+      }
+      const paths = await ensureWorkspaceForActiveConfig(config);
+      const actionId = input.actionId.trim();
+      if (!actionId) {
+        throw new Error("actionId is required");
+      }
+      const actions = await readPendingUserActions(paths);
+      const action = actions.find((item) => item.action_id === actionId);
+      if (!action) {
+        throw new Error(`pending action not found: ${actionId}`);
+      }
+      if (action.kind !== "install_skill" && action.kind !== "commit_schedule" && action.kind !== "meeting_summary") {
+        throw new Error(`unsupported action kind: ${action.kind}`);
+      }
+      const decisions = await readUserActionDecisions(paths);
+      const decision = decisions.find((item) => item.action_id === actionId);
+      if (!decision || decision.decision !== "accepted") {
+        throw new Error(`action is not accepted: ${actionId}`);
+      }
+      if (action.kind === "meeting_summary") {
+        const existingSummary = (await readUserActionResults(paths)).find(
+          (item) => item.action_id === actionId && item.kind === "meeting_summary" && item.status === "recorded"
+        );
+        if (existingSummary) {
+          return {
+            ok: true,
+            actionId,
+            status: "recorded",
+            alreadyApplied: true,
+            result: existingSummary,
+            workspaceRootDir: paths.rootDir
+          };
+        }
+        const record = createMeetingSummaryRecord(config.communityAgentId, action);
+        await writeMeetingSummary(paths, record);
+        await appendAuditLog(paths, {
+          kind: "meeting.summary.confirmed",
+          community_agent_id: config.communityAgentId,
+          action: "meeting.summary",
+          decision: "ask",
+          reason: `user accepted ${actionId}; summary recorded locally`,
+          source_event_id: actionId,
+          envelope_id: typeof action.payload.handoff_id === "string" ? action.payload.handoff_id : void 0,
+          result: "recorded",
+          payload: {
+            summary_id: record.summary_id,
+            room_id: record.room_id,
+            summary_path: `${paths.roomsDir}/${sanitizeSegment3(record.room_id)}.summary.json`,
+            egress: "local_only"
+          }
+        });
+        await appendUserActionResult(paths, {
+          result_id: `result_${Date.now()}_${actionId}`,
+          action_id: actionId,
+          kind: "meeting_summary",
+          status: "recorded",
+          created_at: (/* @__PURE__ */ new Date()).toISOString(),
+          updated_at: (/* @__PURE__ */ new Date()).toISOString(),
+          payload: {
+            summary_id: record.summary_id,
+            room_id: record.room_id,
+            local_summary_file: `${paths.roomsDir}/${sanitizeSegment3(record.room_id)}.summary.json`
+          }
+        });
+        return {
+          ok: true,
+          actionId,
+          status: "recorded",
+          roomId: record.room_id,
+          summaryId: record.summary_id,
+          workspaceRootDir: paths.rootDir
+        };
+      }
+      if (action.kind === "commit_schedule") {
+        const topic = typeof action.payload.topic === "string" ? action.payload.topic : "";
+        const peerAgentId = typeof action.payload.peer_agent_id === "string" ? action.payload.peer_agent_id : "";
+        const negotiationId = typeof action.payload.negotiation_id === "string" ? action.payload.negotiation_id : "";
+        const durationMinutes = typeof action.payload.duration_minutes === "number" && Number.isFinite(action.payload.duration_minutes) ? action.payload.duration_minutes : 30;
+        const selectedWindow = action.payload.selected_window && typeof action.payload.selected_window === "object" && !Array.isArray(action.payload.selected_window) && typeof action.payload.selected_window.start === "string" && typeof action.payload.selected_window.end === "string" ? action.payload.selected_window : null;
+        if (!topic || !peerAgentId || !negotiationId || !selectedWindow) {
+          throw new Error(`commit_schedule action missing required payload: ${actionId}`);
+        }
+        const policy = await readDelegationPolicy(paths, config.communityAgentId);
+        const envelope = createScheduleNegotiateEnvelope({
+          senderAgentId: config.communityAgentId,
+          targetAgentId: peerAgentId,
+          actingFor: policy.principal.userId,
+          kind: "commit",
+          negotiationId,
+          topic,
+          durationMinutes,
+          candidateWindows: [selectedWindow],
+          selectedWindow
+        });
+        await new CommunityClient(config).publishEnvelope(envelope);
+        await appendWorkspaceEnvelope(paths, config.communityAgentId, envelope);
+        await appendAuditLog(paths, {
+          kind: "schedule.commit.sent",
+          community_agent_id: config.communityAgentId,
+          action: "schedule.negotiate.commit",
+          decision: "ask",
+          reason: `user accepted ${actionId}`,
+          envelope_id: envelope.envelope_id,
+          source_event_id: actionId,
+          target_agent_id: peerAgentId,
+          result: "sent",
+          payload: {
+            negotiation_id: negotiationId,
+            selected_window: selectedWindow,
+            acting_for: envelope.acting_for
+          }
+        });
+        await appendUserActionResult(paths, {
+          result_id: `result_${Date.now()}_${actionId}`,
+          action_id: actionId,
+          kind: "schedule_commitment",
+          status: "committed",
+          created_at: (/* @__PURE__ */ new Date()).toISOString(),
+          updated_at: (/* @__PURE__ */ new Date()).toISOString(),
+          payload: {
+            negotiation_id: negotiationId,
+            envelope_id: envelope.envelope_id,
+            selected_window: selectedWindow
+          }
+        });
+        await writeScheduleState(
+          paths,
+          updateScheduleState(
+            await readScheduleState(paths),
+            createScheduleStateFromEnvelope(envelope, "committed", [selectedWindow], selectedWindow, {
+              peerAgentId
+            })
+          )
+        );
+        const room = await createRoomForScheduleCommit(config, paths, {
+          topic,
+          peerAgentId,
+          negotiationId
+        });
+        return {
+          ok: true,
+          actionId,
+          status: "committed",
+          envelopeId: envelope.envelope_id,
+          negotiationId,
+          roomId: room.room_id,
+          workspaceRootDir: paths.rootDir
+        };
+      }
+      const results = await readUserActionResults(paths);
+      const existingFinal = results.filter((item) => item.action_id === actionId).find((item) => item.status === "installed" || item.status === "install_failed");
+      if (existingFinal) {
+        return {
+          ok: existingFinal.status === "installed",
+          actionId,
+          status: existingFinal.status,
+          alreadyApplied: true,
+          result: existingFinal,
+          workspaceRootDir: paths.rootDir
+        };
+      }
+      const skillSlug = typeof action.payload.skill_slug === "string" ? action.payload.skill_slug : "";
+      if (!skillSlug) {
+        throw new Error(`action missing payload.skill_slug: ${actionId}`);
+      }
+      await appendUserActionResult(
+        paths,
+        createInstallSkillActionResult(actionId, "installing", {
+          skill_slug: skillSlug,
+          install_agent: input.agentId ?? "main",
+          install_method: "pending_user_side_installer"
+        })
+      );
+      const result = installOpenClawSkill(skillSlug);
+      const finalStatus = result.ok ? "installed" : "install_failed";
+      const actionResult = createInstallSkillActionResult(actionId, finalStatus, {
+        skill_slug: skillSlug,
+        install_agent: input.agentId ?? "main",
+        install_method: "pending_user_side_installer",
+        install_result: result
+      });
+      await appendUserActionResult(paths, actionResult);
+      const offerId = typeof action.payload.offer_id === "string" ? action.payload.offer_id : void 0;
+      if (offerId) {
+        const offers = await readStagedSkillOffers(paths);
+        const offer = offers.find((item) => item.offer_id === offerId);
+        if (offer) {
+          await writeStagedSkillOffer(
+            paths,
+            attachSkillInstallMetadata(offer, {
+              status: result.ok ? "installed" : "install_failed",
+              install_status: result.ok ? "passed" : "failed",
+              install_method: "openclaw skills install --agent",
+              install_agent: commandContext.agentId,
+              install_home: commandContext.homeDir,
+              install_cwd: commandContext.cwd,
+              install_checked_at: (/* @__PURE__ */ new Date()).toISOString(),
+              install_result: result
+            })
+          );
+        }
+      }
+      return {
+        ok: result.ok,
+        actionId,
+        status: finalStatus,
+        skillSlug,
+        result,
+        actionResult,
+        workspaceRootDir: paths.rootDir
+      };
+    },
+    getStatus: () => status
+  };
+}
+function attachSkillInstallMetadata(offer, metadata) {
+  return {
+    ...offer,
+    ...metadata
+  };
+}
+function readDirectMessageFromHandoff(handoff) {
+  const payload = handoff.payload;
+  const dmId = typeof payload.dm_id === "string" ? payload.dm_id : "";
+  const senderAgentId = typeof payload.sender_agent_id === "string" ? payload.sender_agent_id : "";
+  const recipientAgentId = typeof payload.recipient_agent_id === "string" ? payload.recipient_agent_id : "";
+  const message = typeof payload.message === "string" ? payload.message : "";
+  if (!dmId || !senderAgentId || !recipientAgentId || !message) {
+    return null;
+  }
+  return {
+    dmId,
+    senderAgentId,
+    recipientAgentId,
+    message,
+    intent: typeof payload.intent === "string" ? payload.intent : null,
+    createdAt: typeof payload.created_at === "string" ? payload.created_at : null
+  };
+}
+function createSubagentReplyPendingAction(communityAgentId, handoff, dm, proposal) {
+  return {
+    action_id: `action_subagent_reply_${sanitizeSegment3(dm.dmId)}`,
+    kind: "reply_to_dm",
+    source: "openclaw-bridge",
+    community_agent_id: communityAgentId,
+    status: "pending_user_confirmation",
+    user_confirmation_required: true,
+    created_at: (/* @__PURE__ */ new Date()).toISOString(),
+    title: `\u786E\u8BA4\u56DE\u590D ${dm.senderAgentId}`,
+    summary: `Community Subagent \u5DF2\u8D77\u8349\u4E00\u6761${proposal.risk}\u98CE\u9669\u56DE\u590D\uFF1A${proposal.draft}`,
+    payload: {
+      dm_id: dm.dmId,
+      envelope_id: handoff.envelope_id,
+      handoff_id: handoff.handoff_id,
+      sender_agent_id: dm.senderAgentId,
+      recipient_agent_id: dm.recipientAgentId,
+      message: dm.message,
+      draft_message: proposal.draft,
+      intent: dm.intent,
+      risk_level: proposal.risk,
+      suggested_action: "confirm_subagent_draft_reply",
+      proposal_reason: proposal.reason ?? null
+    }
+  };
+}
+function createMeetingSummaryPendingAction(communityAgentId, handoff, proposal, proposalMeta) {
+  const topic = readString3(handoff.payload.topic) ?? proposal.room_id;
+  return {
+    action_id: `action_meeting_summary_${sanitizeSegment3(proposal.room_id)}_${sanitizeSegment3(handoff.handoff_id)}`,
+    kind: "meeting_summary",
+    source: "openclaw-bridge",
+    community_agent_id: communityAgentId,
+    status: "pending_user_confirmation",
+    user_confirmation_required: true,
+    created_at: (/* @__PURE__ */ new Date()).toISOString(),
+    title: `\u786E\u8BA4\u4F1A\u8BAE\u6458\u8981\uFF1A${topic}`,
+    summary: proposal.summary,
+    payload: {
+      room_id: proposal.room_id,
+      topic,
+      handoff_id: handoff.handoff_id,
+      summary: proposal.summary,
+      todos: proposal.todos,
+      risk_level: "medium",
+      suggested_action: "confirm_meeting_summary",
+      proposal_reason: proposal.reason ?? null,
+      proposal_model: readString3(proposalMeta?.model) ?? null,
+      proposal_run_id: readString3(proposalMeta?.run_id) ?? null,
+      proposal_session_id: readString3(proposalMeta?.session_id) ?? null,
+      egress: "local_only"
+    }
+  };
+}
+function createMeetingSummaryRecord(communityAgentId, action) {
+  const roomId = readString3(action.payload.room_id);
+  const summary = readString3(action.payload.summary);
+  if (!roomId || !summary) {
+    throw new Error(`meeting_summary action missing room_id or summary: ${action.action_id}`);
+  }
+  const todos = Array.isArray(action.payload.todos) ? action.payload.todos.map((todo) => {
+    if (typeof todo === "string") {
+      const text2 = todo.trim();
+      return text2 ? { text: text2, due_at: null, owner: null } : null;
+    }
+    if (!todo || typeof todo !== "object" || Array.isArray(todo)) {
+      return null;
+    }
+    const record = todo;
+    const text = readString3(record.text);
+    return text ? {
+      text,
+      due_at: readString3(record.due_at) ?? null,
+      owner: readString3(record.owner) ?? null
+    } : null;
+  }).filter((todo) => Boolean(todo)) : [];
+  return {
+    summary_id: `summary_${Date.now()}_${sanitizeSegment3(roomId)}`,
+    action_id: action.action_id,
+    room_id: roomId,
+    community_agent_id: communityAgentId,
+    summary,
+    todos,
+    source_handoff_id: readString3(action.payload.handoff_id) ?? null,
+    source_model: readString3(action.payload.proposal_model) ?? null,
+    confirmed_at: (/* @__PURE__ */ new Date()).toISOString(),
+    created_at: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function classifyDirectMessageRisk(message) {
+  const text = `${message.message} ${message.intent ?? ""}`.toLowerCase();
+  if (text.includes("\u5F00\u4F1A") || text.includes("\u4F1A\u8BAE") || text.includes("meeting") || text.includes("\u660E\u5929") || text.includes("\u4E0B\u5348") || text.includes("\u4E0A\u5348") || text.includes("\u53EF\u4EE5\u5417")) {
+    return "medium";
+  }
+  if (text.includes("\u5728\u4E0D\u5728\u7EBF") || text.includes("\u5728\u7EBF") || text.includes("ping") || text.includes("hello") || text.includes("hi") || text.includes("\u6536\u5230") || text.includes("ack")) {
+    return "low";
+  }
+  if (text.includes("?") || text.includes("\uFF1F")) {
+    return "medium";
+  }
+  return "medium";
+}
+function sanitizeSegment3(value) {
+  return value.replace(/[^a-zA-Z0-9._-]+/g, "_");
+}
+function readString3(value) {
+  return typeof value === "string" && value.trim().length > 0 ? value.trim() : void 0;
+}
+function formatDateForTimeZone(value, timeZone) {
+  const parts = new Intl.DateTimeFormat("en-CA", {
+    timeZone,
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit"
+  }).formatToParts(value);
+  const byType = new Map(parts.map((part) => [part.type, part.value]));
+  return `${byType.get("year")}-${byType.get("month")}-${byType.get("day")}`;
+}
+function installOpenClawSkill(slug) {
+  return {
+    ok: false,
+    message: `Skill install for ${slug} is pending user-side installer integration.`,
+    stdout: "",
+    stderr: "openclaw-bridge beta package does not execute local shell installers",
+    code: null
+  };
+}
+
+// src/setup.ts
+import { randomUUID as randomUUID4 } from "node:crypto";
+import { chmod, mkdir as mkdir2, writeFile as writeFile2 } from "node:fs/promises";
+import path3 from "node:path";
+import { pathToFileURL } from "node:url";
+function describeCommunityBridgeSetup() {
+  return {
+    title: "Connect AgentComm Community",
+    protocolVersion: AGENTCOMM_PROTOCOL_VERSION,
+    requiredInputs: [
+      "serverUrl",
+      "auth.method",
+      "agent.openclawWorkspaceId",
+      "agent.openclawAgentId",
+      "agent.displayName",
+      "agent.capabilities"
+    ],
+    optionalInputs: [
+      "communitySubagent.enabled",
+      "communitySubagent.autoApprove",
+      "communitySubagent.agentId",
+      "communitySubagent.displayName",
+      "communitySubagent.model"
+    ],
+    recommendedFlow: [
+      "Register Bridge with AgentComm Platform",
+      "Create Community Persona workspace",
+      "Create OpenClaw Community Subagent after user confirmation",
+      "Write Bridge config patch",
+      "Run validation"
+    ],
+    authMethods: [
+      {
+        method: "browser",
+        label: "Browser login",
+        description: "Complete account login in the Community web app, then continue setup."
+      },
+      {
+        method: "paste_token",
+        label: "Paste registration token",
+        description: "Paste a short-lived token generated by the Community web app."
+      }
+    ]
+  };
+}
+function parseSetupInput(value) {
+  if (!isRecord4(value)) {
+    throw new Error("setup input must be an object");
+  }
+  const auth = readAuthInput(value.auth);
+  const agent = readAgentInput(value.agent);
+  return {
+    serverUrl: requiredString(value.serverUrl, "serverUrl"),
+    auth,
+    agent,
+    pollIntervalMs: readNumber2(value.pollIntervalMs) ?? 3e4,
+    sharingPolicy: {
+      allowProactiveConversation: readBoolean(readRecord(value.sharingPolicy)?.allowProactiveConversation) ?? true,
+      maxContextLevel: "sanitized_summary"
+    },
+    communitySubagent: readCommunitySubagentInput(value.communitySubagent, agent.openclawAgentId)
+  };
+}
+async function runCommunityBridgeSetup(input, context = {}) {
+  const serverUrl = trimTrailingSlash2(input.serverUrl);
+  const accessToken = input.auth.method === "browser" ? input.auth.userAccessToken : input.auth.token;
+  const registration = await registerAgent(serverUrl, accessToken, input);
+  const personaSetup = await setupCommunityPersona(input, registration, context);
+  const bridgeTokenRef = await persistBridgeTokenSecret(personaSetup.workspaceRootDir, registration.bridge_token);
+  return {
+    ok: true,
+    communityAgentId: registration.community_agent_id,
+    personaSetup,
+    policyRevision: registration.policy_snapshot?.policy_revision,
+    configPatch: {
+      plugins: {
+        entries: {
+          "openclaw-bridge": {
+            enabled: true,
+            config: {
+              enabled: true,
+              serverUrl,
+              communityAgentId: registration.community_agent_id,
+              bridgeTokenRef,
+              pollIntervalMs: secondsToMs(registration.heartbeat?.interval_seconds) ?? input.pollIntervalMs,
+              communitySubagent: personaSetup?.subagent ? {
+                enabled: true,
+                agentId: personaSetup.subagent.agentId,
+                workspaceDir: personaSetup.subagent.workspaceDir,
+                agentDir: personaSetup.subagent.agentDir
+              } : void 0
+            }
+          }
+        }
+      }
+    },
+    notes: [
+      "bridgeToken was written to a local 0600 secret file.",
+      "configPatch stores bridgeTokenRef only; no bridge token plaintext is written to OpenClaw config.",
+      "Community Subagent creation belongs to connect/setup, not plugin install."
+    ]
+  };
+}
+async function persistBridgeTokenSecret(communityWorkspaceRoot, bridgeToken) {
+  const secretsDir = path3.join(communityWorkspaceRoot, "secrets");
+  const tokenPath = path3.join(secretsDir, "bridge-token");
+  await mkdir2(secretsDir, { recursive: true, mode: 448 });
+  await writeFile2(tokenPath, `${bridgeToken}
+`, { encoding: "utf8", mode: 384 });
+  await chmod(secretsDir, 448);
+  await chmod(tokenPath, 384);
+  return pathToFileURL(tokenPath).href;
+}
+async function setupCommunityPersona(input, registration, context) {
+  const hostPaths = context.hostPaths ?? {};
+  const paths = await resolvePlatformWorkspacePaths({
+    communityAgentId: registration.community_agent_id,
+    workspaceDir: hostPaths.workspaceDir,
+    agentDir: inferOpenClawAgentDir(hostPaths),
+    stateDir: hostPaths.stateDir,
+    homeDir: hostPaths.homeDir
+  });
+  await ensurePlatformWorkspace(paths, registration.community_agent_id);
+  if (!input.communitySubagent.enabled) {
+    await writePersonaSubagentInfo(
+      paths,
+      registration.community_agent_id,
+      {
+        species: "openclaw",
+        agentId: input.communitySubagent.agentId ?? defaultCommunitySubagentId(input.agent.openclawAgentId),
+        workspaceDir: path3.join(paths.rootDir, "subagent-workspace"),
+        agentDir: path3.join(paths.rootDir, "subagent-agent"),
+        status: "skipped",
+        createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+        setupMode: input.communitySubagent.autoApprove ? "auto_approved" : "interactive_onboarding"
+      }
+    );
+    return {
+      workspaceRootDir: paths.rootDir,
+      subagent: null,
+      status: "skipped",
+      reason: "community subagent disabled by setup input"
+    };
+  }
+  const subagent = await ensureOpenClawCommunitySubagent(input, paths.rootDir, context);
+  await writePersonaSubagentInfo(
+    paths,
+    registration.community_agent_id,
+    {
+      species: "openclaw",
+      agentId: subagent.agentId,
+      workspaceDir: subagent.workspaceDir,
+      agentDir: subagent.agentDir,
+      status: subagent.status,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      setupMode: input.communitySubagent.autoApprove ? "auto_approved" : "interactive_onboarding"
+    }
+  );
+  return {
+    workspaceRootDir: paths.rootDir,
+    subagent,
+    status: subagent.status
+  };
+}
+async function ensureOpenClawCommunitySubagent(input, communityWorkspaceRoot, _context) {
+  const agentId = input.communitySubagent.agentId ?? defaultCommunitySubagentId(input.agent.openclawAgentId);
+  const workspaceDir = path3.join(communityWorkspaceRoot, "subagent-workspace");
+  const agentDir = path3.join(communityWorkspaceRoot, "subagent-agent");
+  await mkdir2(workspaceDir, { recursive: true });
+  await mkdir2(agentDir, { recursive: true });
+  return {
+    agentId,
+    workspaceDir,
+    agentDir,
+    status: "pending_openclaw_setup"
+  };
+}
+async function registerAgent(serverUrl, accessToken, input) {
+  const response = await fetch(`${serverUrl}/v1/agents/register`, {
+    method: "POST",
+    headers: {
+      Authorization: `Bearer ${accessToken}`,
+      "Content-Type": "application/json",
+      Accept: "application/json"
+    },
+    body: JSON.stringify({
+      adapter_instance_id: `community_bridge_${randomUUID4()}`,
+      openclaw_workspace_id: input.agent.openclawWorkspaceId,
+      openclaw_agent_id: input.agent.openclawAgentId,
+      agent_profile: {
+        display_name: input.agent.displayName,
+        capabilities: input.agent.capabilities,
+        supported_intents: ["no_op", "propose_user_conversation"]
+      },
+      sharing_policy: {
+        allow_agent_questions: false,
+        allow_board_posts: false,
+        allow_proactive_conversation: input.sharingPolicy.allowProactiveConversation,
+        max_context_level: input.sharingPolicy.maxContextLevel
+      },
+      heartbeat_preferences: {
+        interval_seconds: Math.max(5, Math.round(input.pollIntervalMs / 1e3))
+      },
+      consent: {
+        consent_revision: `consent_${randomUUID4()}`,
+        approved_by_user_id: "openclaw-local-user",
+        approved_at: (/* @__PURE__ */ new Date()).toISOString()
+      }
+    })
+  });
+  const body = await readJson2(response);
+  if (!response.ok) {
+    throw new Error(`community registration failed: ${response.status}`);
+  }
+  if (!isRegisterAgentResponse(body)) {
+    throw new Error("community registration response is missing agent credentials");
+  }
+  return body;
+}
+function readAuthInput(value) {
+  const record = readRecord(value);
+  const method = requiredString(record?.method, "auth.method");
+  if (method === "browser") {
+    return {
+      method,
+      userAccessToken: requiredString(record?.userAccessToken, "auth.userAccessToken")
+    };
+  }
+  if (method === "paste_token") {
+    return {
+      method,
+      token: requiredString(record?.token, "auth.token")
+    };
+  }
+  throw new Error(`unsupported auth method: ${method}`);
+}
+function readAgentInput(value) {
+  const record = readRecord(value);
+  return {
+    openclawWorkspaceId: requiredString(record?.openclawWorkspaceId, "agent.openclawWorkspaceId"),
+    openclawAgentId: requiredString(record?.openclawAgentId, "agent.openclawAgentId"),
+    displayName: requiredString(record?.displayName, "agent.displayName"),
+    capabilities: readStringArray(record?.capabilities)
+  };
+}
+function readCommunitySubagentInput(value, openclawAgentId) {
+  const record = readRecord(value);
+  return {
+    enabled: readBoolean(record?.enabled) ?? true,
+    autoApprove: readBoolean(record?.autoApprove) ?? false,
+    agentId: readString4(record?.agentId) ?? defaultCommunitySubagentId(openclawAgentId),
+    displayName: readString4(record?.displayName) ?? "AgentComm Community Persona",
+    model: readString4(record?.model)
+  };
+}
+async function readJson2(response) {
+  const text = await response.text();
+  return text.trim().length > 0 ? JSON.parse(text) : null;
+}
+function isRegisterAgentResponse(value) {
+  return isRecord4(value) && typeof value.community_agent_id === "string" && typeof value.bridge_token === "string";
+}
+function requiredString(value, field) {
+  if (typeof value !== "string" || value.trim().length === 0) {
+    throw new Error(`${field} must be a non-empty string`);
+  }
+  return value.trim();
+}
+function readStringArray(value) {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  return value.filter((item) => typeof item === "string" && item.trim().length > 0).map((item) => item.trim());
+}
+function readBoolean(value) {
+  return typeof value === "boolean" ? value : void 0;
+}
+function readNumber2(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function readString4(value) {
+  return typeof value === "string" && value.trim().length > 0 ? value.trim() : void 0;
+}
+function readRecord(value) {
+  return isRecord4(value) ? value : void 0;
+}
+function isRecord4(value) {
+  return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+function trimTrailingSlash2(value) {
+  return value.replace(/\/+$/, "");
+}
+function defaultCommunitySubagentId(openclawAgentId) {
+  return `agentcomm-community-${sanitizeSegment4(openclawAgentId)}`;
+}
+function sanitizeSegment4(value) {
+  return value.replace(/[^a-zA-Z0-9._-]+/g, "-").replace(/^-+|-+$/g, "") || "agent";
+}
+function secondsToMs(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value * 1e3 : void 0;
+}
+
+// index.ts
+var BRIDGE_CONFIG_SCHEMA = {
+  type: "object",
+  additionalProperties: false,
+  properties: {
+    enabled: { type: "boolean", default: false },
+    serverUrl: { type: "string" },
+    communityAgentId: { type: "string" },
+    keepaliveToken: { type: "string" },
+    bridgeToken: { type: "string" },
+    bridgeTokenRef: { type: "string" },
+    pollIntervalMs: {
+      type: "number",
+      minimum: 5e3,
+      default: 3e4
+    },
+    communitySubagent: {
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        enabled: { type: "boolean", default: true },
+        agentId: { type: "string" },
+        workspaceDir: { type: "string" },
+        agentDir: { type: "string" }
+      }
+    },
+    autonomousLoop: {
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        enabled: { type: "boolean", default: false },
+        maxItemsPerPoll: {
+          type: "number",
+          minimum: 1,
+          maximum: 5,
+          default: 1
+        },
+        timeoutSeconds: {
+          type: "number",
+          minimum: 10,
+          maximum: 600,
+          default: 120
+        }
+      }
+    },
+    acceptanceDemo: {
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        enabled: { type: "boolean", default: false },
+        sessionKey: { type: "string" },
+        label: { type: "string" }
+      }
+    }
+  }
+};
+var EmptyParamsSchema = {
+  type: "object",
+  additionalProperties: false,
+  properties: {}
+};
+var toolEntry = defineToolPlugin({
+  id: "openclaw-bridge",
+  name: "Politeia Bridge",
+  description: "Maintain keepalive connectivity and route structured community envelopes for an OpenClaw agent.",
+  activation: {
+    onStartup: true,
+    onConfigPaths: ["plugins.entries.openclaw-bridge"]
+  },
+  configSchema: BRIDGE_CONFIG_SCHEMA,
+  tools: (tool) => [
+    tool({
+      name: "agentcomm_list_agents",
+      description: "List AgentComm agents registered on the connected platform, including display names and online status.",
+      parameters: EmptyParamsSchema,
+      execute: async (_params, _config, context) => {
+        const bridge = createBridgeForApi(context.api);
+        return bridge.listAgents();
+      }
+    }),
+    tool({
+      name: "agentcomm_dm_send",
+      description: "Send a direct message through this OpenClaw agent's AgentComm community persona.",
+      parameters: {
+        type: "object",
+        additionalProperties: false,
+        required: ["targetAgentId", "message"],
+        properties: {
+          targetAgentId: {
+            type: "string",
+            description: "Target AgentComm community agent id, for example agt_agent_openclaw_main."
+          },
+          message: {
+            type: "string",
+            description: "Message body to send."
+          }
+        }
+      },
+      execute: async (params, _config, context) => {
+        const record = params;
+        const bridge = createBridgeForApi(context.api);
+        return bridge.dmSend({
+          targetAgentId: record.targetAgentId,
+          message: record.message,
+          intent: "agent-tool.dm-send"
+        });
+      }
+    }),
+    tool({
+      name: "agentcomm_check_inbox",
+      description: "Check this local AgentComm workspace for recent inbound DMs and pending user decisions.",
+      parameters: EmptyParamsSchema,
+      execute: async (_params, _config, context) => {
+        const bridge = createBridgeForApi(context.api);
+        return bridge.checkInbox();
+      }
+    }),
+    tool({
+      name: "agentcomm_doctor",
+      description: "Diagnose the local AgentComm Bridge configuration and OpenClaw workspace resolver state.",
+      parameters: EmptyParamsSchema,
+      execute: async (_params, _config, context) => {
+        const api = context.api;
+        return runBridgeDoctor(readBridgeConfig(api.pluginConfig), {
+          workspaceDir: api.workspaceDir,
+          agentDir: api.agentDir,
+          stateDir: api.stateDir,
+          homeDir: api.homeDir,
+          agentId: api.agentId
+        });
+      }
+    }),
+    tool({
+      name: "agentcomm_schedule_propose",
+      description: "Start a deterministic AgentComm schedule.negotiate meeting-time proposal with another agent.",
+      parameters: {
+        type: "object",
+        additionalProperties: false,
+        required: ["targetAgentId", "topic", "durationMinutes", "candidateWindows"],
+        properties: {
+          targetAgentId: {
+            type: "string",
+            description: "Target AgentComm community agent id."
+          },
+          topic: {
+            type: "string",
+            description: "Meeting topic."
+          },
+          durationMinutes: {
+            type: "number",
+            minimum: 1,
+            description: "Meeting duration in minutes."
+          },
+          candidateWindows: {
+            type: "array",
+            items: {
+              type: "object",
+              additionalProperties: false,
+              required: ["start", "end"],
+              properties: {
+                start: { type: "string" },
+                end: { type: "string" }
+              }
+            }
+          }
+        }
+      },
+      execute: async (params, _config, context) => {
+        const record = parseScheduleProposeParams(params);
+        const bridge = createBridgeForApi(context.api);
+        return bridge.schedulePropose(record);
+      }
+    }),
+    tool({
+      name: "agentcomm_room_send",
+      description: "Send a text message into an AgentComm meeting room as this local community persona.",
+      parameters: {
+        type: "object",
+        additionalProperties: false,
+        required: ["roomId", "message"],
+        properties: {
+          roomId: {
+            type: "string",
+            description: "Target AgentComm room id."
+          },
+          message: {
+            type: "string",
+            description: "Message body to send into the room."
+          }
+        }
+      },
+      execute: async (params, _config, context) => {
+        const bridge = createBridgeForApi(context.api);
+        return bridge.roomSend({
+          ...parseRoomSendParams(params),
+          speakerKind: "agent",
+          intent: "agent-tool.room.send"
+        });
+      }
+    })
+  ]
+});
+var registerToolEntry = toolEntry.register.bind(toolEntry);
+toolEntry.register = (api) => {
+  registerToolEntry(api);
+  if (api.registrationMode === "cli-metadata") {
+    return;
+  }
+  let hostPaths = {
+    workspaceDir: api.workspaceDir,
+    agentDir: api.agentDir,
+    homeDir: api.homeDir,
+    agentId: api.agentId
+  };
+  const bridge = createCommunityBridgeService(
+    () => readBridgeConfig(api.pluginConfig),
+    () => hostPaths
+  );
+  api.registerGatewayMethod("communityBridge.status", async ({ respond }) => {
+    respond(true, bridge.getStatus());
+  });
+  api.registerGatewayMethod("communityBridge.setup.describe", async ({ respond }) => {
+    respond(true, describeCommunityBridgeSetup());
+  });
+  api.registerGatewayMethod("communityBridge.protocol", async ({ respond }) => {
+    respond(true, {
+      ok: true,
+      protocolVersion: AGENTCOMM_PROTOCOL_VERSION,
+      bridgeVersion: AGENTCOMM_BRIDGE_PACKAGE_VERSION
+    });
+  });
+  api.registerGatewayMethod("communityBridge.doctor", async ({ respond }) => {
+    respond(true, await runBridgeDoctor(readBridgeConfig(api.pluginConfig), hostPaths));
+  });
+  api.registerGatewayMethod("communityBridge.setup.register", async ({ params, respond }) => {
+    respond(
+      true,
+      await runCommunityBridgeSetup(parseSetupInput(params), {
+        hostPaths
+      })
+    );
+  });
+  api.registerGatewayMethod("communityBridge.workspaceStatus", async ({ respond }) => {
+    const config = readBridgeConfig(api.pluginConfig);
+    const active = config.enabled && config.communityAgentId ? config.communityAgentId : void 0;
+    if (!active) {
+      respond(true, {
+        ok: false,
+        reason: "community agent id unavailable"
+      });
+      return;
+    }
+    const paths = await resolvePlatformWorkspacePaths({
+      communityAgentId: active,
+      workspaceDir: hostPaths.workspaceDir,
+      agentDir: inferOpenClawAgentDir(hostPaths),
+      stateDir: hostPaths.stateDir,
+      homeDir: hostPaths.homeDir
+    });
+    const state = await readPlatformWorkspaceState(paths);
+    const personaProfile = await readPersonaProfile(paths);
+    const profileSubagent = isRecord5(personaProfile?.subagent) ? personaProfile.subagent : null;
+    const communitySubagent = config.communitySubagent ?? profileSubagent;
+    const subagentWorkspaceDir = isRecord5(communitySubagent) && typeof communitySubagent.workspaceDir === "string" ? communitySubagent.workspaceDir : null;
+    respond(true, {
+      ok: true,
+      workspaceDir: hostPaths.workspaceDir ?? process.cwd(),
+      agentDir: inferOpenClawAgentDir(hostPaths) ?? hostPaths.agentDir ?? null,
+      stateDir: hostPaths.stateDir ?? null,
+      strategy: paths.strategy,
+      rootDir: paths.rootDir,
+      personaProfilePath: paths.personaProfilePath,
+      pendingActionsPath: paths.pendingActionsPath,
+      communitySubagent,
+      subagentHandoff: subagentWorkspaceDir ? resolveSubagentHandoffPaths(subagentWorkspaceDir) : null,
+      personaProfile,
+      state
+    });
+  });
+  api.registerGatewayMethod("communityBridge.pollOnce", async ({ respond }) => {
+    respond(true, await bridge.pollOnce());
+  });
+  api.registerGatewayMethod("communityBridge.autonomousLoopOnce", async ({ params, respond }) => {
+    const record = isRecord5(params) ? params : {};
+    const maxItems = typeof record.maxItems === "number" && Number.isInteger(record.maxItems) && record.maxItems > 0 ? Math.min(record.maxItems, 5) : void 0;
+    const handoffId = typeof record.handoffId === "string" && record.handoffId.trim().length > 0 ? record.handoffId.trim() : void 0;
+    respond(true, await bridge.runAutonomousLoopOnce({ maxItems, handoffId }));
+  });
+  api.registerGatewayMethod("communityBridge.applyProposal", async ({ params, respond }) => {
+    respond(true, await bridge.applyProposal(parseApplyProposalParams(params)));
+  });
+  api.registerGatewayMethod("communityBridge.listAgents", async ({ respond }) => {
+    respond(true, await bridge.listAgents());
+  });
+  api.registerGatewayMethod("communityBridge.checkInbox", async ({ respond }) => {
+    respond(true, await bridge.checkInbox());
+  });
+  api.registerGatewayMethod("communityBridge.postPublish", async ({ params, respond }) => {
+    if (!params || typeof params !== "object") {
+      throw new Error("postPublish params must be an object");
+    }
+    const record = params;
+    if (typeof record.title !== "string" || record.title.trim().length === 0) {
+      throw new Error("title must be a non-empty string");
+    }
+    if (typeof record.body !== "string" || record.body.trim().length === 0) {
+      throw new Error("body must be a non-empty string");
+    }
+    respond(
+      true,
+      await bridge.postPublish({
+        title: record.title.trim(),
+        body: record.body.trim(),
+        intent: typeof record.intent === "string" && record.intent.trim().length > 0 ? record.intent.trim() : void 0,
+        tags: Array.isArray(record.tags) ? record.tags.filter((item) => typeof item === "string" && item.trim().length > 0) : void 0
+      })
+    );
+  });
+  api.registerGatewayMethod("communityBridge.dmSend", async ({ params, respond }) => {
+    if (!params || typeof params !== "object") {
+      throw new Error("dmSend params must be an object");
+    }
+    const record = params;
+    if (typeof record.targetAgentId !== "string" || record.targetAgentId.trim().length === 0) {
+      throw new Error("targetAgentId must be a non-empty string");
+    }
+    if (typeof record.message !== "string" || record.message.trim().length === 0) {
+      throw new Error("message must be a non-empty string");
+    }
+    respond(
+      true,
+      await bridge.dmSend({
+        targetAgentId: record.targetAgentId.trim(),
+        message: record.message.trim(),
+        intent: typeof record.intent === "string" && record.intent.trim().length > 0 ? record.intent.trim() : void 0
+      })
+    );
+  });
+  api.registerGatewayMethod("communityBridge.schedulePropose", async ({ params, respond }) => {
+    respond(true, await bridge.schedulePropose(parseScheduleProposeParams(params)));
+  });
+  api.registerGatewayMethod("communityBridge.roomSend", async ({ params, respond }) => {
+    respond(true, await bridge.roomSend(parseRoomSendParams(params)));
+  });
+  api.registerGatewayMethod("communityBridge.prepareMeetingSummary", async ({ params, respond }) => {
+    respond(true, await bridge.prepareMeetingSummary(parseMeetingSummaryParams(params)));
+  });
+  api.registerGatewayMethod("communityBridge.skillQuery", async ({ params, respond }) => {
+    if (!params || typeof params !== "object") {
+      throw new Error("skillQuery params must be an object");
+    }
+    const record = params;
+    if (typeof record.need !== "string" || record.need.trim().length === 0) {
+      throw new Error("need must be a non-empty string");
+    }
+    respond(
+      true,
+      await bridge.skillQuery({
+        need: record.need.trim(),
+        context: typeof record.context === "string" && record.context.trim().length > 0 ? record.context.trim() : void 0,
+        intent: typeof record.intent === "string" && record.intent.trim().length > 0 ? record.intent.trim() : void 0,
+        tags: Array.isArray(record.tags) ? record.tags.filter((item) => typeof item === "string" && item.trim().length > 0) : void 0
+      })
+    );
+  });
+  api.registerGatewayMethod("communityBridge.skillInstall", async ({ params, respond }) => {
+    if (!params || typeof params !== "object") {
+      throw new Error("skillInstall params must be an object");
+    }
+    const record = params;
+    const offerId = typeof record.offerId === "string" && record.offerId.trim().length > 0 ? record.offerId.trim() : void 0;
+    const skillSlug = typeof record.skillSlug === "string" && record.skillSlug.trim().length > 0 ? record.skillSlug.trim() : void 0;
+    if (!offerId && !skillSlug) {
+      throw new Error("offerId or skillSlug is required");
+    }
+    respond(
+      true,
+      await bridge.skillInstall({
+        offerId,
+        skillSlug,
+        agentId: typeof record.agentId === "string" && record.agentId.trim().length > 0 ? record.agentId.trim() : void 0
+      })
+    );
+  });
+  api.registerGatewayMethod("communityBridge.confirmAction", async ({ params, respond }) => {
+    const input = parseActionDecisionParams(params);
+    respond(
+      true,
+      await bridge.confirmAction({
+        actionId: input.actionId,
+        reason: input.reason,
+        decidedBy: input.decidedBy
+      })
+    );
+  });
+  api.registerGatewayMethod("communityBridge.rejectAction", async ({ params, respond }) => {
+    const input = parseActionDecisionParams(params);
+    respond(
+      true,
+      await bridge.rejectAction({
+        actionId: input.actionId,
+        reason: input.reason,
+        decidedBy: input.decidedBy
+      })
+    );
+  });
+  api.registerGatewayMethod("communityBridge.applyAcceptedAction", async ({ params, respond }) => {
+    if (!isRecord5(params)) {
+      throw new Error("applyAcceptedAction params must be an object");
+    }
+    const actionId = typeof params.actionId === "string" ? params.actionId.trim() : "";
+    if (!actionId) {
+      throw new Error("actionId must be a non-empty string");
+    }
+    respond(
+      true,
+      await bridge.applyAcceptedAction({
+        actionId,
+        agentId: typeof params.agentId === "string" && params.agentId.trim().length > 0 ? params.agentId.trim() : void 0
+      })
+    );
+  });
+  if (api.registrationMode === "full") {
+    api.registerService({
+      id: "openclaw-bridge",
+      start: (ctx) => {
+        const runtimeContext = ctx;
+        hostPaths = mergeHostPaths(hostPaths, {
+          workspaceDir: runtimeContext.workspaceDir,
+          agentDir: runtimeContext.agentDir,
+          stateDir: runtimeContext.stateDir,
+          homeDir: runtimeContext.homeDir,
+          agentId: runtimeContext.agentId
+        });
+        return bridge.start();
+      },
+      stop: () => bridge.stop()
+    });
+  }
+};
+var index_default = toolEntry;
+function createBridgeForApi(api) {
+  const hostPaths = {
+    workspaceDir: api.workspaceDir,
+    agentDir: api.agentDir,
+    stateDir: api.stateDir,
+    homeDir: api.homeDir,
+    agentId: api.agentId
+  };
+  return createCommunityBridgeService(
+    () => readBridgeConfig(api.pluginConfig),
+    () => hostPaths
+  );
+}
+async function runBridgeDoctor(config, hostPaths) {
+  const checks = [];
+  const activeToken = getActiveConfig(config)?.connectionToken;
+  const inferredAgentDir = inferOpenClawAgentDir(hostPaths);
+  checks.push({
+    name: "protocol_version",
+    status: "passed",
+    detail: AGENTCOMM_PROTOCOL_VERSION
+  });
+  checks.push({
+    name: "enabled",
+    status: config.enabled ? "passed" : "failed",
+    detail: config.enabled ? "bridge enabled" : "plugins.entries.openclaw-bridge.config.enabled is not true"
+  });
+  checks.push({
+    name: "server_url",
+    status: isValidServerUrl(config.serverUrl) ? "passed" : "failed",
+    detail: config.serverUrl ?? "missing serverUrl"
+  });
+  checks.push({
+    name: "community_agent_id",
+    status: config.communityAgentId ? "passed" : "failed",
+    detail: config.communityAgentId ?? "missing communityAgentId"
+  });
+  checks.push({
+    name: "bridge_token",
+    status: activeToken ? "passed" : "failed",
+    detail: activeToken ? `configured len=${activeToken.length}` : "missing keepaliveToken/bridgeToken or unresolved bridgeTokenRef"
+  });
+  checks.push({
+    name: "host_home",
+    status: hostPaths.homeDir ? "passed" : "warning",
+    detail: hostPaths.homeDir ?? "host did not provide homeDir; falling back to process environment"
+  });
+  checks.push({
+    name: "agent_dir",
+    status: inferredAgentDir ? "passed" : "warning",
+    detail: inferredAgentDir ?? "agentDir was not provided and could not be inferred yet"
+  });
+  let workspace = null;
+  if (config.communityAgentId) {
+    try {
+      const paths = await resolvePlatformWorkspacePaths({
+        communityAgentId: config.communityAgentId,
+        workspaceDir: hostPaths.workspaceDir,
+        agentDir: inferredAgentDir,
+        stateDir: hostPaths.stateDir,
+        homeDir: hostPaths.homeDir
+      });
+      const state = await readPlatformWorkspaceState(paths);
+      const personaProfile = await readPersonaProfile(paths);
+      workspace = {
+        ok: true,
+        strategy: paths.strategy,
+        rootDir: paths.rootDir,
+        stateExists: Boolean(state),
+        personaProfileExists: Boolean(personaProfile)
+      };
+      checks.push({
+        name: "workspace_resolver",
+        status: "passed",
+        detail: `${paths.strategy}: ${paths.rootDir}`
+      });
+    } catch (error) {
+      workspace = {
+        ok: false,
+        error: error instanceof Error ? error.message : String(error)
+      };
+      checks.push({
+        name: "workspace_resolver",
+        status: "failed",
+        detail: workspace.error
+      });
+    }
+  }
+  return {
+    ok: checks.every((check) => check.status !== "failed"),
+    protocolVersion: AGENTCOMM_PROTOCOL_VERSION,
+    bridgeVersion: AGENTCOMM_BRIDGE_PACKAGE_VERSION,
+    checks,
+    hostPaths: {
+      workspaceDir: hostPaths.workspaceDir ?? null,
+      agentDir: hostPaths.agentDir ?? null,
+      inferredAgentDir: inferredAgentDir ?? null,
+      stateDir: hostPaths.stateDir ?? null,
+      homeDir: hostPaths.homeDir ?? null,
+      agentId: hostPaths.agentId ?? null
+    },
+    config: {
+      enabled: config.enabled,
+      serverUrl: config.serverUrl ?? null,
+      communityAgentId: config.communityAgentId ?? null,
+      pollIntervalMs: config.pollIntervalMs,
+      hasToken: Boolean(activeToken)
+    },
+    workspace
+  };
+}
+function isValidServerUrl(value) {
+  if (!value) return false;
+  try {
+    const url = new URL(value);
+    return url.protocol === "http:" || url.protocol === "https:";
+  } catch {
+    return false;
+  }
+}
+function isRecord5(value) {
+  return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+function parseActionDecisionParams(params) {
+  if (!isRecord5(params)) {
+    throw new Error("action decision params must be an object");
+  }
+  const actionId = typeof params.actionId === "string" ? params.actionId.trim() : "";
+  if (!actionId) {
+    throw new Error("actionId must be a non-empty string");
+  }
+  const decidedBy = params.decidedBy === "user" || params.decidedBy === "platform" || params.decidedBy === "bridge" ? params.decidedBy : void 0;
+  return {
+    actionId,
+    reason: typeof params.reason === "string" && params.reason.trim().length > 0 ? params.reason.trim() : void 0,
+    decidedBy
+  };
+}
+function parseApplyProposalParams(params) {
+  if (!isRecord5(params)) {
+    throw new Error("applyProposal params must be an object");
+  }
+  const handoffId = typeof params.handoffId === "string" ? params.handoffId.trim() : "";
+  if (!handoffId) {
+    throw new Error("handoffId must be a non-empty string");
+  }
+  const proposalRecord = isRecord5(params.proposal) ? params.proposal : params;
+  const action = proposalRecord.action;
+  if (action === "meeting.summary") {
+    const roomId = typeof proposalRecord.room_id === "string" ? proposalRecord.room_id.trim() : "";
+    const summary = typeof proposalRecord.summary === "string" ? proposalRecord.summary.trim() : "";
+    const todos = Array.isArray(proposalRecord.todos) ? proposalRecord.todos.map((todo) => {
+      if (typeof todo === "string") {
+        const text2 = todo.trim();
+        return text2 ? { text: text2, due_at: null, owner: null } : null;
+      }
+      if (!isRecord5(todo)) {
+        return null;
+      }
+      const text = typeof todo.text === "string" ? todo.text.trim() : "";
+      if (!text) {
+        return null;
+      }
+      return {
+        text,
+        due_at: typeof todo.due_at === "string" && todo.due_at.trim().length > 0 ? todo.due_at.trim() : null,
+        owner: typeof todo.owner === "string" && todo.owner.trim().length > 0 ? todo.owner.trim() : null
+      };
+    }).filter((todo) => Boolean(todo)) : [];
+    if (!roomId) throw new Error("proposal.room_id must be a non-empty string");
+    if (!summary) throw new Error("proposal.summary must be a non-empty string");
+    if (todos.length === 0) throw new Error("proposal.todos must contain at least one item");
+    return {
+      handoffId,
+      proposal: {
+        action,
+        room_id: roomId,
+        summary,
+        todos,
+        reason: typeof proposalRecord.reason === "string" && proposalRecord.reason.trim().length > 0 ? proposalRecord.reason.trim() : void 0
+      },
+      proposalMeta: isRecord5(params.proposalMeta) ? params.proposalMeta : void 0
+    };
+  }
+  const risk = proposalRecord.risk;
+  const draft = typeof proposalRecord.draft === "string" ? proposalRecord.draft.trim() : "";
+  if (action !== "dm.reply") {
+    throw new Error(`unsupported proposal action: ${String(action)}`);
+  }
+  if (risk !== "low" && risk !== "medium" && risk !== "high") {
+    throw new Error(`unsupported proposal risk: ${String(risk)}`);
+  }
+  if (!draft) {
+    throw new Error("proposal.draft must be a non-empty string");
+  }
+  return {
+    handoffId,
+    proposal: {
+      action,
+      risk,
+      draft,
+      reason: typeof proposalRecord.reason === "string" && proposalRecord.reason.trim().length > 0 ? proposalRecord.reason.trim() : void 0
+    },
+    proposalMeta: isRecord5(params.proposalMeta) ? params.proposalMeta : void 0
+  };
+}
+function parseMeetingSummaryParams(params) {
+  if (!isRecord5(params)) {
+    throw new Error("prepareMeetingSummary params must be an object");
+  }
+  const roomId = typeof params.roomId === "string" ? params.roomId.trim() : "";
+  if (!roomId) {
+    throw new Error("roomId must be a non-empty string");
+  }
+  return { roomId };
+}
+function parseScheduleProposeParams(params) {
+  if (!isRecord5(params)) {
+    throw new Error("schedulePropose params must be an object");
+  }
+  const targetAgentId = typeof params.targetAgentId === "string" ? params.targetAgentId.trim() : "";
+  const topic = typeof params.topic === "string" ? params.topic.trim() : "";
+  const durationMinutes = typeof params.durationMinutes === "number" && Number.isFinite(params.durationMinutes) ? params.durationMinutes : 0;
+  const candidateWindows = Array.isArray(params.candidateWindows) ? params.candidateWindows.filter(isRecord5).map((item) => ({
+    start: typeof item.start === "string" ? item.start.trim() : "",
+    end: typeof item.end === "string" ? item.end.trim() : ""
+  })).filter((item) => item.start.length > 0 && item.end.length > 0) : [];
+  if (!targetAgentId) throw new Error("targetAgentId must be a non-empty string");
+  if (!topic) throw new Error("topic must be a non-empty string");
+  if (durationMinutes <= 0) throw new Error("durationMinutes must be a positive number");
+  if (candidateWindows.length === 0) throw new Error("candidateWindows must contain at least one window");
+  return {
+    targetAgentId,
+    topic,
+    durationMinutes,
+    candidateWindows,
+    actingFor: typeof params.actingFor === "string" && params.actingFor.trim().length > 0 ? params.actingFor.trim() : void 0
+  };
+}
+function parseRoomSendParams(params) {
+  if (!isRecord5(params)) {
+    throw new Error("roomSend params must be an object");
+  }
+  const roomId = typeof params.roomId === "string" ? params.roomId.trim() : "";
+  const message = typeof params.message === "string" ? params.message.trim() : "";
+  if (!roomId) throw new Error("roomId must be a non-empty string");
+  if (!message) throw new Error("message must be a non-empty string");
+  return {
+    roomId,
+    message,
+    speakerKind: params.speakerKind === "agent" || params.speakerKind === "human" ? params.speakerKind : void 0,
+    speakerLabel: typeof params.speakerLabel === "string" && params.speakerLabel.trim().length > 0 ? params.speakerLabel.trim() : void 0,
+    intent: typeof params.intent === "string" && params.intent.trim().length > 0 ? params.intent.trim() : void 0
+  };
+}
+export {
+  index_default as default
+};