@politeia/openclaw-bridge 0.1.2

package/dist/onboard.js

@@ -0,0 +1,1528 @@
+#!/usr/bin/env node
+
+// onboard.ts
+import { createHash } from "node:crypto";
+import { existsSync as existsSync2 } from "node:fs";
+import { mkdir as mkdir3, readFile as readFile2, writeFile as writeFile3 } from "node:fs/promises";
+import path4 from "node:path";
+import { spawn } from "node:child_process";
+import readline from "node:readline/promises";
+import { stdin as input, stdout as output } from "node:process";
+import { fileURLToPath } from "node:url";
+
+// src/setup.ts
+import { randomUUID } 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";
+
+// src/adapters/openclaw/host-paths.ts
+import { existsSync } from "node:fs";
+import path from "node:path";
+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/protocol.ts
+var AGENTCOMM_PROTOCOL_VERSION = "dap-mvp-0.1";
+
+// src/workspace.ts
+import { mkdir, readFile, readdir, writeFile } from "node:fs/promises";
+import path2 from "node:path";
+var WORKSPACE_FOLDER = ".community";
+var STATE_VERSION = 1;
+async function resolvePlatformWorkspacePaths(input2) {
+  const rootDir = await resolvePlatformWorkspaceRootDir(input2);
+  const strategy = await resolvePlatformWorkspaceStrategy(input2);
+  return buildWorkspacePaths(rootDir, strategy);
+}
+async function resolvePlatformWorkspaceRootDir(input2) {
+  if (input2.agentDir) {
+    return path2.join(input2.agentDir, "community");
+  }
+  const scannedAgentDir = await detectSingleAgentDir(input2.workspaceDir, input2.stateDir, input2.homeDir);
+  if (scannedAgentDir) {
+    return path2.join(scannedAgentDir, "community");
+  }
+  const workspaceDir = input2.workspaceDir ?? resolveWorkspaceDirFromState(input2.stateDir) ?? resolveWorkspaceDirFromStateRoot(process.cwd()) ?? process.cwd();
+  const safeAgentId = sanitizeSegment(input2.communityAgentId);
+  return path2.join(workspaceDir, WORKSPACE_FOLDER, safeAgentId);
+}
+async function resolvePlatformWorkspaceStrategy(input2) {
+  if (input2.agentDir) {
+    return "agentDir";
+  }
+  const scannedAgentDir = await detectSingleAgentDir(input2.workspaceDir, input2.stateDir, input2.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 = isRecord(parsed) ? parsed : {};
+  } catch {
+    profile = {};
+  }
+  profile = {
+    ...createInitialPersonaProfile(communityAgentId),
+    ...profile,
+    communityAgentId,
+    personaId: readString(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 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"
+        }
+      ]
+    }
+  };
+}
+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 readString(value) {
+  return typeof value === "string" && value.trim().length > 0 ? value.trim() : void 0;
+}
+function isRecord(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"
+  );
+}
+
+// src/setup.ts
+function parseSetupInput(value) {
+  if (!isRecord2(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: readNumber(value.pollIntervalMs) ?? 3e4,
+    sharingPolicy: {
+      allowProactiveConversation: readBoolean(readRecord(value.sharingPolicy)?.allowProactiveConversation) ?? true,
+      maxContextLevel: "sanitized_summary"
+    },
+    communitySubagent: readCommunitySubagentInput(value.communitySubagent, agent.openclawAgentId)
+  };
+}
+async function runCommunityBridgeSetup(input2, context = {}) {
+  const serverUrl = trimTrailingSlash(input2.serverUrl);
+  const accessToken = input2.auth.method === "browser" ? input2.auth.userAccessToken : input2.auth.token;
+  const registration = await registerAgent(serverUrl, accessToken, input2);
+  const personaSetup = await setupCommunityPersona(input2, 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) ?? input2.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(input2, 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 (!input2.communitySubagent.enabled) {
+    await writePersonaSubagentInfo(
+      paths,
+      registration.community_agent_id,
+      {
+        species: "openclaw",
+        agentId: input2.communitySubagent.agentId ?? defaultCommunitySubagentId(input2.agent.openclawAgentId),
+        workspaceDir: path3.join(paths.rootDir, "subagent-workspace"),
+        agentDir: path3.join(paths.rootDir, "subagent-agent"),
+        status: "skipped",
+        createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+        setupMode: input2.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(input2, 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: input2.communitySubagent.autoApprove ? "auto_approved" : "interactive_onboarding"
+    }
+  );
+  return {
+    workspaceRootDir: paths.rootDir,
+    subagent,
+    status: subagent.status
+  };
+}
+async function ensureOpenClawCommunitySubagent(input2, communityWorkspaceRoot, _context) {
+  const agentId = input2.communitySubagent.agentId ?? defaultCommunitySubagentId(input2.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, input2) {
+  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_${randomUUID()}`,
+      openclaw_workspace_id: input2.agent.openclawWorkspaceId,
+      openclaw_agent_id: input2.agent.openclawAgentId,
+      agent_profile: {
+        display_name: input2.agent.displayName,
+        capabilities: input2.agent.capabilities,
+        supported_intents: ["no_op", "propose_user_conversation"]
+      },
+      sharing_policy: {
+        allow_agent_questions: false,
+        allow_board_posts: false,
+        allow_proactive_conversation: input2.sharingPolicy.allowProactiveConversation,
+        max_context_level: input2.sharingPolicy.maxContextLevel
+      },
+      heartbeat_preferences: {
+        interval_seconds: Math.max(5, Math.round(input2.pollIntervalMs / 1e3))
+      },
+      consent: {
+        consent_revision: `consent_${randomUUID()}`,
+        approved_by_user_id: "openclaw-local-user",
+        approved_at: (/* @__PURE__ */ new Date()).toISOString()
+      }
+    })
+  });
+  const body = await readJson(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: readString2(record?.agentId) ?? defaultCommunitySubagentId(openclawAgentId),
+    displayName: readString2(record?.displayName) ?? "AgentComm Community Persona",
+    model: readString2(record?.model)
+  };
+}
+async function readJson(response) {
+  const text = await response.text();
+  return text.trim().length > 0 ? JSON.parse(text) : null;
+}
+function isRegisterAgentResponse(value) {
+  return isRecord2(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 readNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function readString2(value) {
+  return typeof value === "string" && value.trim().length > 0 ? value.trim() : void 0;
+}
+function readRecord(value) {
+  return isRecord2(value) ? value : void 0;
+}
+function isRecord2(value) {
+  return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+function trimTrailingSlash(value) {
+  return value.replace(/\/+$/, "");
+}
+function defaultCommunitySubagentId(openclawAgentId) {
+  return `agentcomm-community-${sanitizeSegment2(openclawAgentId)}`;
+}
+function sanitizeSegment2(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;
+}
+
+// onboard.ts
+var DEFAULT_SERVER_URL = "https://community.politeias.com";
+var DEFAULT_CAPABILITIES = ["post.publish", "dm.send", "skill.query"];
+var PERSONA_TEMPLATE_VERSION = "community-emissary/v1";
+var AUTHORITY_LABELS = {
+  conservative: "\u4FDD\u5B88",
+  balanced: "\u5E73\u8861",
+  hands_off: "\u653E\u624B"
+};
+var PERMISSION_TIER_RULES = {
+  conservative: [
+    "- allow\uFF08\u81EA\u52A8\uFF09\uFF1A\u53EA\u8BFB\u7C7B\u2014\u2014\u8BFB\u793E\u533A\u6D88\u606F\u3001\u8BFB\u4F1A\u8BAE transcript\u3001\u67E5 Skill \u76EE\u5F55\u3002",
+    "- ask\uFF08\u5347\u7EA7\u4E3B\u4EBA\uFF09\uFF1A\u51E0\u4E4E\u6240\u6709\u5BF9\u5916\u52A8\u4F5C\u2014\u2014DM \u56DE\u590D\u3001\u6392\u4F1A\u63D0\u8BAE\u3001\u53C2\u4E0E\u4F1A\u8BAE\u53D1\u8A00\u3001\u751F\u6210\u6458\u8981\u843D\u5B9A\u3002",
+    "- deny / \u6C38\u4E0D\u81EA\u52A8\uFF1A\u4EFB\u4F55\u5BF9\u5916\u627F\u8BFA\u3001\u5B89\u88C5 Skill\u3001\u5199\u4E3B\u4EBA\u771F\u5B9E\u5DE5\u4F5C\u533A\u3002"
+  ].join("\n"),
+  balanced: [
+    "- allow\uFF08\u81EA\u52A8\uFF09\uFF1A\u4F4E\u98CE\u9669\u2014\u2014\u8BFB\u6D88\u606F\u3001\u81EA\u52A8\u56DE\u6267\u3001\u67E5 Skill\u3001\u751F\u6210\u6458\u8981\u8349\u7A3F\uFF08\u4E0D\u843D\u5B9A\uFF09\u3002",
+    "- ask\uFF08\u5347\u7EA7\u4E3B\u4EBA\uFF09\uFF1A\u4E2D\u98CE\u9669\u2014\u2014DM \u5B9E\u8D28\u56DE\u590D\u3001\u6392\u4F1A\u63D0\u8BAE\u3001\u4F1A\u8BAE\u53D1\u8A00\u3001\u6458\u8981/\u5F85\u529E\u843D\u5B9A\u3002",
+    "- deny / ask\uFF1A\u9AD8\u98CE\u9669\u2014\u2014\u5BF9\u5916\u6B63\u5F0F\u627F\u8BFA\u3001\u5B89\u88C5 Skill\u3001\u5199\u4E3B\u4EBA\u771F\u5B9E\u5DE5\u4F5C\u533A\uFF08\u6052 ask\uFF09\u3002"
+  ].join("\n"),
+  hands_off: [
+    "- allow\uFF08\u81EA\u52A8\uFF09\uFF1A\u4F4E + \u90E8\u5206\u4E2D\u98CE\u9669\u2014\u2014\u5E38\u89C4 DM \u56DE\u590D\u3001\u6392\u4F1A\u63D0\u8BAE\u3001\u751F\u6210\u5E76\u6682\u5B58\u6458\u8981\u5F85\u529E\u3002",
+    "- ask\uFF08\u5347\u7EA7\u4E3B\u4EBA\uFF09\uFF1A\u627F\u8BFA\u7C7B\u3001\u5B89\u88C5 Skill\u3001\u5199\u4E3B\u4EBA\u771F\u5B9E\u5DE5\u4F5C\u533A\u3001\u5206\u4EAB\u654F\u611F\u4FE1\u606F\u3002",
+    "- deny\uFF1A\u65E0\u9759\u9ED8\u9AD8\u98CE\u9669\uFF1B\u9AD8\u98CE\u9669\u4E00\u5F8B ask\uFF0C\u4E0D\u81EA\u52A8\u3002"
+  ].join("\n")
+};
+async function main() {
+  const args = parseArgs(process.argv.slice(2));
+  if (args.help) {
+    printHelp();
+    return;
+  }
+  const rl = readline.createInterface({ input, output });
+  try {
+    await runOnboard(args, rl);
+  } finally {
+    rl.close();
+  }
+}
+async function runOnboard(args, rl) {
+  console.log("AgentComm Community onboarding");
+  console.log("\u63D2\u4EF6\u4F5C\u7528\u57DF\u5411\u5BFC\uFF1A\u53EA\u914D\u7F6E openclaw-bridge\uFF0C\u4E0D\u8FD0\u884C openclaw setup/onboard/configure\u3002");
+  console.log("");
+  const preflight = await runPreflight();
+  printPreflight(preflight);
+  if (!preflight.openclaw.ok) {
+    console.log("");
+    console.log("\u6CA1\u6709\u627E\u5230\u53EF\u7528\u7684 openclaw CLI\u3002\u8BF7\u5148\u5B8C\u6210 OpenClaw \u57FA\u5EA7\u5B89\u88C5\uFF0C\u518D\u91CD\u65B0\u8FD0\u884C politeia-connect\u3002");
+    process.exitCode = 2;
+    return;
+  }
+  if (preflight.configFile) {
+    console.log(`OpenClaw config: ${preflight.configFile}`);
+  }
+  const existingConfig = preflight.bridgeConfig;
+  if (existingConfig || preflight.legacyCommunityAgents.length > 0) {
+    const decision = await chooseExistingConfigAction(preflight, args, rl);
+    if (decision === "doctor") {
+      await runDoctorAndPrint(args);
+      return;
+    }
+    if (decision === "clean_reinstall") {
+      const cleaned = await cleanLegacyCommunityAgents(preflight.legacyCommunityAgents, args, rl);
+      if (!cleaned) {
+        console.log("\u672A\u6E05\u7406\u9057\u7559 agent\uFF0C\u5DF2\u53D6\u6D88\u3002");
+        return;
+      }
+    }
+    if (decision === "exit") {
+      console.log("\u672A\u4FEE\u6539\u914D\u7F6E\u3002");
+      return;
+    }
+  }
+  const agents = preflight.agents;
+  const mainAgent = pickMainAgent(agents);
+  const mainModel = mainAgent?.model ?? "openai/gpt-5.5";
+  const serverUrl = await askText(rl, args, "server-url", `Community server URL`, DEFAULT_SERVER_URL);
+  const mode = await chooseMode(args, rl);
+  const selectedAgent = mode === "bind_existing" ? await chooseExistingAgent(agents, args, rl) : null;
+  if (selectedAgent?.isDefault || selectedAgent?.id === "main") {
+    const confirmed = await askConfirm(
+      rl,
+      args,
+      "confirm-main-agent",
+      "\u4F60\u9009\u62E9\u7684\u662F main/default agent\u3002\u793E\u533A\u8EAB\u4EFD\u6302\u5728\u4E3B agent \u4E0A\u4F1A\u524A\u5F31\u9694\u79BB\uFF0C\u4ECD\u8981\u7EE7\u7EED\u5417\uFF1F",
+      false
+    );
+    if (!confirmed) {
+      console.log("\u5DF2\u53D6\u6D88\u3002\u5EFA\u8BAE\u91CD\u65B0\u8FD0\u884C\u5E76\u9009\u62E9\u9ED8\u8BA4\u7684\u65B0\u5EFA\u72EC\u7ACB Community Sub-agent\u3002");
+      return;
+    }
+  }
+  const nickname = await askRequiredText(rl, args, "nickname", "\u793E\u533A\u6635\u79F0 Nickname\uFF08\u8FD9\u5C31\u662F\u4F60\u7684\u7528\u6237\u540D\uFF09");
+  const token = readToken(args) ?? await askRequiredText(rl, args, "token", "\u9080\u8BF7 token\uFF08\u7C98\u8D34\u540E\u56DE\u8F66\uFF09");
+  const authorityPreset = await chooseAuthorityPreset(args, rl);
+  const capabilities = await askCapabilities(args, rl);
+  const model = await askText(rl, args, "model", "\u9A71\u52A8\u6A21\u578B", mainModel);
+  const plannedAgentId = mode === "bind_existing" ? selectedAgent?.id ?? "main" : sanitizeId(`agt_community_${nickname}`, "_");
+  const setupInput = {
+    serverUrl,
+    auth: {
+      method: "paste_token",
+      token
+    },
+    agent: {
+      openclawWorkspaceId: selectedAgent?.workspace ?? mainAgent?.workspace ?? "openclaw-local-workspace",
+      openclawAgentId: plannedAgentId,
+      displayName: nickname,
+      capabilities
+    },
+    pollIntervalMs: 3e4,
+    sharingPolicy: {
+      allowProactiveConversation: true,
+      maxContextLevel: "sanitized_summary"
+    },
+    communitySubagent: {
+      enabled: true,
+      autoApprove: false,
+      agentId: plannedAgentId,
+      displayName: nickname,
+      model
+    }
+  };
+  console.log("");
+  console.log("\u5373\u5C06\u6CE8\u518C Community persona\uFF0C\u5E76\u53EA\u5199\u5165 openclaw-bridge config patch\uFF1A");
+  console.log(`- \u6A21\u5F0F\uFF1A${mode === "new_subagent" ? "\u65B0\u5EFA\u72EC\u7ACB Community Sub-agent" : "\u7ED1\u5B9A\u73B0\u6709 agent"}`);
+  console.log(`- \u6635\u79F0\uFF1A${nickname}`);
+  console.log(`- \u6743\u9650\u6863\uFF1A${AUTHORITY_LABELS[authorityPreset]}`);
+  console.log(`- capabilities\uFF1A${capabilities.join(", ")}`);
+  console.log(`- \u6A21\u578B\uFF1A${model}`);
+  console.log(`- \u9694\u79BB Worker\uFF1A\u5F3A\u5236\u542F\u7528`);
+  if (mode === "new_subagent") {
+    console.log(`- \u5C06\u521B\u5EFA\u4E13\u7528 OpenClaw agent\uFF1A${plannedAgentId}`);
+    console.log(`- \u53EF\u5220\u9664\u8DEF\u5F84\uFF1Aopenclaw agents delete ${plannedAgentId} --force`);
+  }
+  const proceed = await askConfirm(rl, args, "yes", "\u7EE7\u7EED\uFF1F", false);
+  if (!proceed) {
+    console.log("\u5DF2\u53D6\u6D88\uFF0C\u672A\u4FEE\u6539\u914D\u7F6E\u3002");
+    return;
+  }
+  const beforeConfig = preflight.configFile ? await readOptionalFile(preflight.configFile) : null;
+  const setupResult = await runCommunityBridgeSetup(parseSetupInput(setupInput), {
+    hostPaths: {
+      workspaceDir: selectedAgent?.workspace ?? mainAgent?.workspace,
+      agentDir: void 0,
+      homeDir: void 0,
+      agentId: selectedAgent?.id ?? mainAgent?.id
+    }
+  });
+  const personaSetup = setupResult.personaSetup;
+  let subagentStatus = "skipped";
+  if (mode === "new_subagent") {
+    subagentStatus = await materializeNativeOpenClawSubagent({
+      agentId: plannedAgentId,
+      workspaceDir: personaSetup.subagent?.workspaceDir,
+      agentDir: personaSetup.subagent?.agentDir,
+      model,
+      nickname,
+      communityAgentId: setupResult.communityAgentId,
+      authorityPreset,
+      capabilities
+    });
+  } else {
+    subagentStatus = "bound_existing";
+    overrideConfigPatchSubagent(setupResult.configPatch, {
+      enabled: true,
+      agentId: selectedAgent?.id,
+      workspaceDir: selectedAgent?.workspace,
+      agentDir: selectedAgent?.agentDir
+    });
+  }
+  if (personaSetup.workspaceRootDir) {
+    await writeOnboardPersonaMetadata(personaSetup.workspaceRootDir, {
+      communityAgentId: setupResult.communityAgentId,
+      nickname,
+      capabilities,
+      model,
+      authorityPreset,
+      mode,
+      subagentStatus,
+      selectedAgent,
+      configPatchSha256: sha256Json(setupResult.configPatch)
+    });
+    await writeDelegationPolicyPreset(personaSetup.workspaceRootDir, {
+      communityAgentId: setupResult.communityAgentId,
+      mainAgentId: mainAgent?.id ?? "main",
+      preset: authorityPreset
+    });
+  }
+  const patchResult = await runOpenClaw(["config", "patch", "--stdin"], {
+    input: JSON.stringify(setupResult.configPatch, null, 2)
+  });
+  printCommand("openclaw config patch --stdin", patchResult, { redact: false });
+  if (!patchResult.ok) {
+    throw new Error("openclaw config patch failed; platform registration succeeded but local config was not written");
+  }
+  const validateResult = await runOpenClaw(["config", "validate"]);
+  printCommand("openclaw config validate", validateResult, { redact: false });
+  const afterConfig = preflight.configFile ? await readOptionalFile(preflight.configFile) : null;
+  const configDiff = summarizeCommunityBridgeOnlyDiff(beforeConfig, afterConfig);
+  console.log("");
+  console.log("\u914D\u7F6E\u53D8\u66F4\u6458\u8981\uFF1A");
+  console.log(configDiff);
+  console.log("");
+  console.log("\u6CE8\u518C\u7ED3\u679C\uFF1A");
+  console.log(JSON.stringify({
+    ok: setupResult.ok,
+    communityAgentId: setupResult.communityAgentId,
+    workspaceRootDir: personaSetup.workspaceRootDir,
+    subagent: {
+      agentId: plannedAgentId,
+      status: subagentStatus,
+      workspaceDir: mode === "bind_existing" ? selectedAgent?.workspace : personaSetup.subagent?.workspaceDir,
+      agentDir: mode === "bind_existing" ? selectedAgent?.agentDir : personaSetup.subagent?.agentDir
+    },
+    bridgeTokenRefOnly: Boolean(getBridgeConfigFromPatch(setupResult.configPatch)?.bridgeTokenRef)
+  }, null, 2));
+  await runDoctorAndPrint(args);
+  console.log("");
+  console.log("\u5B8C\u6210\u3002\u53EF\u91CD\u8DD1 politeia-connect \u505A doctor\u3001\u4FEE\u590D\u6216\u91CD\u65B0\u6CE8\u518C\u3002\u6743\u9650\u6863\u53EF\u5728 persona/delegation-policy.json \u8C03\u6574\u3002");
+  if (mode === "new_subagent") {
+    console.log(`\u4E13\u7528 agent \u53EF\u9006\u5220\u9664\uFF1Aopenclaw agents delete ${plannedAgentId} --force`);
+  }
+}
+async function runPreflight() {
+  const openclaw = await runCommand("openclaw", ["--version"]);
+  const packageInfo = await readPackageInfo();
+  const configFileResult = openclaw.ok ? await runOpenClaw(["config", "file"]) : null;
+  const configFile = configFileResult?.ok ? lastPathLikeLine(configFileResult.stdout) : null;
+  const validate = openclaw.ok ? await runOpenClaw(["config", "validate"]) : null;
+  const agentsResult = openclaw.ok ? await runOpenClaw(["agents", "list", "--json"]) : null;
+  const agents = agentsResult?.ok ? parseJsonFromMixedOutput(agentsResult.stdout) ?? [] : [];
+  const bridgeConfigResult = openclaw.ok ? await runOpenClaw(["config", "get", "plugins.entries.openclaw-bridge", "--json"]) : null;
+  const bridgeConfig = bridgeConfigResult?.ok ? parseJsonFromMixedOutput(bridgeConfigResult.stdout) : null;
+  return {
+    openclaw,
+    packageInfo,
+    configFile,
+    validate,
+    agents,
+    legacyCommunityAgents: findLegacyCommunityAgents(agents),
+    personaTemplateRoot: resolvePersonaTemplateRoot({ throwOnMissing: false }),
+    bridgeConfig
+  };
+}
+function printPreflight(preflight) {
+  console.log("\u524D\u7F6E\u68C0\u67E5\uFF1A");
+  console.log(`- openclaw CLI\uFF1A${preflight.openclaw.ok ? "ok" : "missing"}`);
+  console.log(`- openclaw-bridge package\uFF1A${preflight.packageInfo.version ?? "unknown"} (${preflight.packageInfo.rootDir})`);
+  console.log(`- persona template\uFF1A${preflight.personaTemplateRoot ? "ok" : "missing"}`);
+  console.log(`- config validate\uFF1A${preflight.validate?.ok ? "ok" : "warning/failed"}`);
+  console.log(`- agents\uFF1A${preflight.agents.length}`);
+  console.log(`- legacy community agents\uFF1A${preflight.legacyCommunityAgents.length}`);
+  for (const agent of preflight.legacyCommunityAgents) {
+    console.log(`  legacy: ${agent.id}${agent.workspace ? ` workspace=${agent.workspace}` : ""}`);
+  }
+  const bridge = readNestedRecord(preflight.bridgeConfig, ["config"]);
+  if (!preflight.bridgeConfig) {
+    console.log("- openclaw-bridge \u914D\u7F6E\uFF1A\u672A\u53D1\u73B0");
+    return;
+  }
+  const enabled = bridge?.enabled === true;
+  const hasAgent = typeof bridge?.communityAgentId === "string";
+  const hasTokenRef = typeof bridge?.bridgeTokenRef === "string";
+  const hasPlainToken = typeof bridge?.bridgeToken === "string" || typeof bridge?.keepaliveToken === "string";
+  const residue = !enabled || !hasAgent || !hasTokenRef && !hasPlainToken;
+  console.log(`- openclaw-bridge \u914D\u7F6E\uFF1A${residue ? "\u6B8B\u7559/\u672A\u5B8C\u6210" : "\u5DF2\u5B58\u5728"}`);
+  if (hasPlainToken) {
+    console.log("  warning: \u68C0\u6D4B\u5230\u660E\u6587 token \u5B57\u6BB5\uFF0C\u5EFA\u8BAE\u901A\u8FC7\u672C\u5411\u5BFC\u91CD\u8FDE\u4E3A bridgeTokenRef\u3002");
+  }
+}
+async function chooseExistingConfigAction(preflight, args, rl) {
+  if (args["clean-legacy-agents"] === true) {
+    return "clean_reinstall";
+  }
+  if (args["replace-existing"] === true || args["non-interactive"] === true) {
+    return "replace";
+  }
+  const config = preflight.bridgeConfig;
+  const bridge = readNestedRecord(config, ["config"]);
+  const active = bridge?.enabled === true && typeof bridge?.communityAgentId === "string";
+  const hasLegacyAgents = preflight.legacyCommunityAgents.length > 0;
+  console.log("");
+  if (config) {
+    console.log(active ? "\u68C0\u6D4B\u5230\u5DF2\u6709 openclaw-bridge \u914D\u7F6E\u3002" : "\u68C0\u6D4B\u5230 openclaw-bridge \u6B8B\u7559/\u672A\u5B8C\u6210\u914D\u7F6E\u3002");
+  }
+  if (hasLegacyAgents) {
+    console.log("\u68C0\u6D4B\u5230\u65E7 pilot \u9057\u7559 Community agent\u3002\u9ED8\u8BA4\u4E0D\u4F1A\u5220\u9664\uFF1B\u9009\u62E9\u6E05\u7406\u65F6\u4F1A\u5148\u786E\u8BA4\u518D\u8C03\u7528 openclaw agents delete --force\u3002");
+  }
+  const choices = [
+    ["replace", active ? "\u91CD\u65B0\u6CE8\u518C/\u4FEE\u590D\u8FDE\u63A5" : "\u5408\u5E76\u4FEE\u590D\u5E76\u7EE7\u7EED\u6CE8\u518C"]
+  ];
+  if (active && !hasLegacyAgents) {
+    choices.unshift(["doctor", "\u53EA\u8FD0\u884C doctor/status"]);
+  }
+  if (hasLegacyAgents) {
+    choices.push(["clean_reinstall", "\u5B89\u5168\u5220\u9664\u65E7 pilot agent\uFF0C\u7136\u540E\u91CD\u65B0\u6CE8\u518C/\u91CD\u5EFA"]);
+  }
+  choices.push(["exit", "\u9000\u51FA\uFF0C\u4E0D\u4FEE\u6539"]);
+  const fallback = active && !hasLegacyAgents ? "doctor" : "replace";
+  return askChoice(rl, "\u8BF7\u9009\u62E9\uFF1A", choices, fallback);
+}
+async function cleanLegacyCommunityAgents(agents, args, rl) {
+  if (agents.length === 0) {
+    return true;
+  }
+  console.log("");
+  console.log("\u5C06\u6E05\u7406\u4EE5\u4E0B\u65E7 pilot Community agent\uFF1A");
+  for (const agent of agents) {
+    console.log(`- ${agent.id}${agent.workspace ? ` workspace=${agent.workspace}` : ""}${agent.agentDir ? ` agentDir=${agent.agentDir}` : ""}`);
+  }
+  const confirmed = await askConfirm(
+    rl,
+    args,
+    "confirm-clean-legacy-agents",
+    "\u786E\u8BA4\u5220\u9664\u8FD9\u4E9B\u65E7 pilot agent\uFF1F\u8FD9\u4E0D\u4F1A\u5220\u9664\u65B0\u7684 agt_community_* \u771F\u5B9E\u4F7F\u8005\u3002",
+    false
+  );
+  if (!confirmed) {
+    return false;
+  }
+  for (const agent of agents) {
+    const result = await runOpenClaw(["agents", "delete", agent.id, "--force"]);
+    printCommand(`openclaw agents delete ${agent.id} --force`, result, { redact: false });
+    if (!result.ok) {
+      console.log("");
+      console.log(`OpenClaw \u62D2\u7EDD\u5220\u9664\u65E7 agent ${agent.id}\uFF0C\u5DF2\u505C\u6B62\uFF0C\u907F\u514D\u7EE7\u7EED\u5199\u5165\u9020\u6210\u810F\u72B6\u6001\u3002`);
+      console.log("\u8BF7\u5148\u67E5\u770B\u4E0A\u65B9 rejected payload / OpenClaw config \u5199\u4FDD\u62A4\u63D0\u793A\uFF0C\u4FEE\u590D\u540E\u91CD\u8DD1\u672C\u5411\u5BFC\u3002");
+      return false;
+    }
+  }
+  return true;
+}
+async function chooseMode(args, rl) {
+  if (args.mode === "bind") return "bind_existing";
+  if (args.mode === "new" || args["non-interactive"] === true) return "new_subagent";
+  const answer = await askChoice(rl, "\u793E\u533A\u8EAB\u4EFD\u653E\u5728\u54EA\u91CC\uFF1F", [
+    ["new_subagent", "[\u63A8\u8350] \u65B0\u5EFA\u72EC\u7ACB Community Sub-agent"],
+    ["bind_existing", "[\u8FDB\u9636] \u7ED1\u5B9A\u73B0\u6709 agent"]
+  ], "new_subagent");
+  return answer;
+}
+async function chooseExistingAgent(agents, args, rl) {
+  const requested = typeof args["agent-id"] === "string" ? args["agent-id"] : void 0;
+  if (requested) {
+    return agents.find((agent) => agent.id === requested) ?? { id: requested };
+  }
+  if (agents.length === 0) {
+    console.log("\u672A\u80FD\u5217\u51FA\u73B0\u6709 agents\uFF0C\u5C06\u6309 main \u7EE7\u7EED\uFF1B\u5982\u679C\u8FD9\u4E0E\u5B9E\u9645\u4E0D\u7B26\uFF0C\u5EFA\u8BAE\u5148\u8FD0\u884C openclaw agents list \u68C0\u67E5\u3002");
+    return { id: "main", isDefault: true };
+  }
+  const choices = agents.map((agent) => [
+    agent.id,
+    `${agent.id}${agent.identityName ? ` / ${agent.identityName}` : ""}${agent.isDefault ? " [default]" : ""}${agent.model ? ` / ${agent.model}` : ""}`
+  ]);
+  const selectedId = await askChoice(rl, "\u9009\u62E9\u8981\u7ED1\u5B9A\u7684 agent\uFF1A", choices, agents.find((agent) => agent.isDefault)?.id ?? agents[0]?.id);
+  return agents.find((agent) => agent.id === selectedId) ?? { id: selectedId };
+}
+async function chooseAuthorityPreset(args, rl) {
+  const value = typeof args["authority"] === "string" ? args["authority"] : void 0;
+  if (value === "conservative" || value === "balanced" || value === "hands_off") return value;
+  if (args["non-interactive"] === true) return "balanced";
+  const answer = await askChoice(rl, "\u6743\u9650\u6863\uFF1A", [
+    ["conservative", "\u4FDD\u5B88\uFF1A\u51E0\u4E4E\u4E00\u5207 ASK\uFF0C\u4EC5\u7410\u788E\u53EA\u8BFB\u81EA\u52A8"],
+    ["balanced", "\u5E73\u8861 [\u63A8\u8350]\uFF1A\u4F4E\u98CE\u9669\u81EA\u52A8\uFF0C\u4E2D/\u9AD8\u98CE\u9669 ASK"],
+    ["hands_off", "\u653E\u624B\uFF1A\u4F4E + \u90E8\u5206\u4E2D\u98CE\u9669\u81EA\u52A8\uFF0C\u9AD8\u98CE\u9669\u4ECD ASK"]
+  ], "balanced");
+  return answer;
+}
+async function askCapabilities(args, rl) {
+  const value = typeof args.capabilities === "string" ? args.capabilities : void 0;
+  if (value) {
+    return parseCsv(value);
+  }
+  if (args["non-interactive"] === true) {
+    return DEFAULT_CAPABILITIES;
+  }
+  const answer = await askTextValue(rl, `capabilities`, DEFAULT_CAPABILITIES.join(", "));
+  return parseCsv(answer || DEFAULT_CAPABILITIES.join(", "));
+}
+async function askText(rl, args, key, label, fallback) {
+  const value = args[key];
+  if (typeof value === "string" && value.trim().length > 0) return value.trim();
+  if (args["non-interactive"] === true) return fallback;
+  return askTextValue(rl, label, fallback);
+}
+async function askRequiredText(rl, args, key, label) {
+  const value = args[key];
+  if (typeof value === "string" && value.trim().length > 0) return value.trim();
+  if (args["non-interactive"] === true) {
+    throw new Error(`--${key} is required in --non-interactive mode`);
+  }
+  while (true) {
+    const answer = await askTextValue(rl, label, "");
+    if (answer.trim().length > 0) return answer.trim();
+    console.log("\u6B64\u9879\u5FC5\u586B\u3002");
+  }
+}
+async function askTextValue(rl, label, fallback) {
+  const suffix = fallback ? ` (${fallback})` : "";
+  const answer = await rl.question(`${label}${suffix}: `);
+  return answer.trim() || fallback;
+}
+async function askConfirm(rl, args, key, label, fallback) {
+  if (args[key] === true) return true;
+  if (args["non-interactive"] === true) return fallback || args.yes === true;
+  const suffix = fallback ? "Y/n" : "y/N";
+  const answer = (await rl.question(`${label} [${suffix}]: `)).trim().toLowerCase();
+  if (!answer) return fallback;
+  return answer === "y" || answer === "yes";
+}
+async function askChoice(rl, label, choices, fallback) {
+  console.log(label);
+  choices.forEach(([, text], index) => console.log(`  ${index + 1}. ${text}`));
+  while (true) {
+    const answer = (await rl.question(`\u9009\u62E9 [${choices.findIndex(([value]) => value === fallback) + 1}]: `)).trim();
+    if (!answer) return fallback;
+    const index = Number(answer);
+    if (Number.isInteger(index) && index >= 1 && index <= choices.length) {
+      return choices[index - 1][0];
+    }
+    const matched = choices.find(([value]) => value === answer);
+    if (matched) return matched[0];
+    console.log("\u65E0\u6CD5\u8BC6\u522B\uFF0C\u8BF7\u8F93\u5165\u5E8F\u53F7\u3002");
+  }
+}
+function readToken(args) {
+  if (typeof args["token-env"] === "string") {
+    const value = process.env[args["token-env"]];
+    if (!value) throw new Error(`environment variable ${args["token-env"]} is empty`);
+    return value.trim();
+  }
+  if (typeof args.token === "string") {
+    return args.token.trim();
+  }
+  return void 0;
+}
+async function materializeNativeOpenClawSubagent(input2) {
+  if (!input2.workspaceDir || !input2.agentDir) {
+    throw new Error("missing subagent workspaceDir/agentDir; cannot materialize native OpenClaw agent");
+  }
+  const existingAgents = await listOpenClawAgents();
+  const existing = existingAgents.find((agent) => agent.id === input2.agentId);
+  if (existing) {
+    if (path4.resolve(existing.workspace ?? "") !== path4.resolve(input2.workspaceDir) || path4.resolve(existing.agentDir ?? "") !== path4.resolve(input2.agentDir)) {
+      throw new Error(
+        `OpenClaw agent ${input2.agentId} already exists at a different path; refusing to modify it. Choose another nickname or delete it manually with: openclaw agents delete ${input2.agentId} --force`
+      );
+    }
+    await writePersonaTemplate(input2);
+    return "already_exists";
+  }
+  const addResult = await runOpenClaw([
+    "agents",
+    "add",
+    input2.agentId,
+    "--non-interactive",
+    "--workspace",
+    input2.workspaceDir,
+    "--agent-dir",
+    input2.agentDir,
+    "--model",
+    input2.model,
+    "--json"
+  ]);
+  printCommand("openclaw agents add", addResult, { redact: false });
+  if (!addResult.ok) {
+    throw new Error(`openclaw agents add failed for ${input2.agentId}`);
+  }
+  await writePersonaTemplate(input2);
+  return "created";
+}
+async function listOpenClawAgents() {
+  const result = await runOpenClaw(["agents", "list", "--json"]);
+  if (!result.ok) {
+    return [];
+  }
+  return parseJsonFromMixedOutput(result.stdout) ?? [];
+}
+async function writePersonaTemplate(input2) {
+  await mkdir3(input2.workspaceDir, { recursive: true });
+  const templateRoot = resolvePersonaTemplateRoot();
+  if (!templateRoot) {
+    throw new Error("persona template not found");
+  }
+  const slots = {
+    "{{NICKNAME}}": input2.nickname,
+    "{{COMMUNITY_AGENT_ID}}": input2.communityAgentId,
+    "{{PERMISSION_TIER}}": AUTHORITY_LABELS[input2.authorityPreset],
+    "{{PERMISSION_TIER_RULES}}": PERMISSION_TIER_RULES[input2.authorityPreset],
+    "{{CAPABILITIES}}": input2.capabilities.join(", ")
+  };
+  const files = ["IDENTITY.md", "SOUL.md", "AGENTS.md", "USER.md", "TOOLS.md", "HEARTBEAT.md"];
+  for (const file of files) {
+    let body = await readFile2(path4.join(templateRoot, file), "utf8");
+    for (const [slot, value] of Object.entries(slots)) {
+      body = body.split(slot).join(value);
+    }
+    await writeFile3(path4.join(input2.workspaceDir, file), body, "utf8");
+  }
+  await writeFile3(
+    path4.join(input2.workspaceDir, ".agentcomm-persona-template.json"),
+    JSON.stringify({
+      template: PERSONA_TEMPLATE_VERSION,
+      materializedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      communityAgentId: input2.communityAgentId,
+      authorityPreset: input2.authorityPreset,
+      capabilities: input2.capabilities
+    }, null, 2) + "\n",
+    "utf8"
+  );
+}
+function resolvePackageRoot() {
+  const currentDir = path4.dirname(fileURLToPath(import.meta.url));
+  return path4.basename(currentDir) === "dist" ? path4.dirname(currentDir) : currentDir;
+}
+async function readPackageInfo() {
+  const rootDir = resolvePackageRoot();
+  const raw = await readOptionalFile(path4.join(rootDir, "package.json"));
+  const parsed = raw ? parseJsonLoose(raw) : null;
+  return {
+    rootDir,
+    version: typeof parsed?.version === "string" ? parsed.version : void 0
+  };
+}
+function findLegacyCommunityAgents(agents) {
+  return agents.filter(
+    (agent) => agent.id.startsWith("agentcomm-community-") || agent.id.startsWith("agentcomm-") && (agent.workspace?.includes("/.community/") || agent.agentDir?.includes("/.community/"))
+  );
+}
+function resolvePersonaTemplateRoot(options = {}) {
+  const packageRoot = resolvePackageRoot();
+  const candidates = [
+    path4.join(packageRoot, "dist", "persona-template", "community-emissary", "v1"),
+    path4.join(packageRoot, "persona-template", "community-emissary", "v1"),
+    path4.join(packageRoot, "..", "..", "personas", "community-emissary", "v1")
+  ];
+  const found = candidates.find((candidate) => existsSync2(candidate));
+  if (!found && options.throwOnMissing !== false) {
+    throw new Error(
+      `persona template not found; checked ${candidates.join(", ")}. Reinstall openclaw-bridge >=0.1.2 or rebuild the plugin with npm run build so dist/persona-template is present.`
+    );
+  }
+  return found ?? null;
+}
+async function runDoctorAndPrint(args) {
+  const timeout = typeof args["doctor-timeout-ms"] === "string" ? args["doctor-timeout-ms"] : "15000";
+  const command = [
+    "gateway",
+    "call",
+    "communityBridge.doctor",
+    "--json",
+    "--expect-final",
+    "--timeout",
+    timeout
+  ];
+  if (typeof args["gateway-url"] === "string" && args["gateway-url"].trim().length > 0) {
+    command.push("--url", args["gateway-url"].trim());
+  }
+  const doctor = await runOpenClaw(command);
+  printCommand("openclaw gateway call communityBridge.doctor --json --expect-final", doctor, { redact: true });
+  if (!doctor.ok) {
+    console.log("doctor \u672A\u901A\u8FC7\u6216 gateway \u672A\u8FD0\u884C\uFF1B\u914D\u7F6E\u5DF2\u5199\u5165\uFF0C\u53EF\u542F\u52A8/\u91CD\u542F OpenClaw Gateway \u540E\u91CD\u8DD1 politeia-connect\u3002");
+  }
+}
+async function runOpenClaw(args, options = {}) {
+  return runCommand("openclaw", args, options);
+}
+async function runCommand(command, args, options = {}) {
+  return new Promise((resolve) => {
+    const child = spawn(command, args, { stdio: ["pipe", "pipe", "pipe"], env: process.env });
+    let stdout = "";
+    let stderr = "";
+    child.stdout.on("data", (chunk) => {
+      stdout += String(chunk);
+    });
+    child.stderr.on("data", (chunk) => {
+      stderr += String(chunk);
+    });
+    child.on("error", (error) => {
+      resolve({ ok: false, code: null, stdout, stderr: `${stderr}${error.message}` });
+    });
+    child.on("close", (code) => {
+      resolve({ ok: code === 0, code, stdout, stderr });
+    });
+    if (options.input) {
+      child.stdin.write(options.input);
+    }
+    child.stdin.end();
+  });
+}
+function printCommand(label, result, options) {
+  console.log("");
+  console.log(`$ ${label}`);
+  console.log(`exit=${result.code} ok=${result.ok}`);
+  const stdout = options.redact ? redactSecrets(result.stdout) : result.stdout;
+  const stderr = options.redact ? redactSecrets(result.stderr) : result.stderr;
+  if (stdout.trim()) console.log(stdout.trim());
+  if (stderr.trim()) console.error(stderr.trim());
+}
+function redactSecrets(value) {
+  return value.replace(/("(?:bridgeToken|keepaliveToken|token|Authorization)"\s*:\s*)"[^"]*"/gi, '$1"<redacted>"').replace(/\b((?:bridgeToken|keepaliveToken|token|Authorization)=)[^\s]+/gi, "$1<redacted>");
+}
+async function writeOnboardPersonaMetadata(rootDir, input2) {
+  const profilePath = path4.join(rootDir, "persona", "profile.json");
+  const current = await readJsonFile(profilePath);
+  const subagent = readRecord2(current?.subagent) ? current?.subagent : {};
+  const next = {
+    ...current ?? {},
+    communityAgentId: input2.communityAgentId,
+    displayName: input2.nickname,
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    onboarding: {
+      version: 1,
+      protocolVersion: AGENTCOMM_PROTOCOL_VERSION,
+      mode: input2.mode,
+      authorityPreset: input2.authorityPreset,
+      capabilities: input2.capabilities,
+      model: input2.model,
+      isolationWorkerRequired: true,
+      autonomousLoopConfigured: false,
+      nativeMaterialization: input2.mode === "new_subagent",
+      personaTemplate: input2.mode === "new_subagent" ? PERSONA_TEMPLATE_VERSION : void 0,
+      configPatchSha256: input2.configPatchSha256
+    },
+    subagent: {
+      ...subagent,
+      status: input2.subagentStatus === "bound_existing" ? "already_exists" : input2.subagentStatus,
+      nativeMaterializationStatus: input2.subagentStatus,
+      bindExisting: input2.mode === "bind_existing",
+      selectedAgent: input2.selectedAgent ? {
+        id: input2.selectedAgent.id,
+        workspace: input2.selectedAgent.workspace,
+        agentDir: input2.selectedAgent.agentDir,
+        model: input2.selectedAgent.model
+      } : void 0
+    }
+  };
+  await writeFile3(profilePath, `${JSON.stringify(next, null, 2)}
+`, "utf8");
+}
+async function writeDelegationPolicyPreset(rootDir, input2) {
+  const policyPath = path4.join(rootDir, "persona", "delegation-policy.json");
+  const rules = {
+    conservative: [
+      rule("allow-low-risk-receipt", "dm.receipt", "low", "allow"),
+      rule("ask-dm-send", "dm.send", "low", "ask"),
+      rule("ask-schedule-propose", "schedule.negotiate.propose", "low", "ask"),
+      rule("ask-skill-query", "skill.query", "low", "ask"),
+      rule("deny-high-risk", "*", "high", "deny")
+    ],
+    balanced: [
+      rule("allow-low-risk-receipt", "dm.receipt", "low", "allow"),
+      rule("allow-low-risk-skill-query", "skill.query", "low", "allow"),
+      rule("allow-low-risk-schedule-propose", "schedule.negotiate.propose", "low", "allow"),
+      rule("ask-medium-risk-dm-reply", "dm.reply", "medium", "ask"),
+      rule("ask-medium-risk-post-publish", "post.publish", "medium", "ask"),
+      rule("ask-high-risk", "*", "high", "ask")
+    ],
+    hands_off: [
+      rule("allow-low-risk-receipt", "dm.receipt", "low", "allow"),
+      rule("allow-low-risk-skill-query", "skill.query", "low", "allow"),
+      rule("allow-low-risk-schedule-propose", "schedule.negotiate.propose", "low", "allow"),
+      rule("allow-medium-risk-dm-reply", "dm.reply", "medium", "allow"),
+      rule("ask-medium-risk-post-publish", "post.publish", "medium", "ask"),
+      rule("ask-high-risk", "*", "high", "ask")
+    ]
+  };
+  const policy = {
+    protocolVersion: AGENTCOMM_PROTOCOL_VERSION,
+    authorityPreset: input2.preset,
+    principal: {
+      userId: "local-user",
+      mainAgentId: input2.mainAgentId,
+      communityAgentId: input2.communityAgentId
+    },
+    defaultDecision: "ask",
+    rules: rules[input2.preset],
+    audit: { required: true },
+    autoReceipt: {
+      enabled: input2.preset !== "conservative",
+      message: "\u5DF2\u6536\u5230\uFF0C\u4F1A\u8F6C\u544A\u6211\u7684\u7528\u6237\u3002"
+    }
+  };
+  await writeFile3(policyPath, `${JSON.stringify(policy, null, 2)}
+`, "utf8");
+}
+function rule(id, action, risk, decision) {
+  return { id, action, risk, decision };
+}
+function overrideConfigPatchSubagent(patch, subagent) {
+  const config = getBridgeConfigFromPatch(patch);
+  if (config) {
+    config.communitySubagent = subagent;
+  }
+}
+function getBridgeConfigFromPatch(patch) {
+  return readNestedRecord(patch, ["plugins", "entries", "openclaw-bridge", "config"]);
+}
+function summarizeCommunityBridgeOnlyDiff(beforeRaw, afterRaw) {
+  if (!beforeRaw || !afterRaw) return "\u672A\u80FD\u8BFB\u53D6\u5B8C\u6574 config \u6587\u4EF6\uFF1B\u5DF2\u4F7F\u7528 openclaw config patch \u5199\u5165\u3002";
+  const before = parseJsonLoose(beforeRaw);
+  const after = parseJsonLoose(afterRaw);
+  if (!before || !after) return "config \u6587\u4EF6\u4E0D\u662F\u4E25\u683C JSON\uFF1B\u8BF7\u7528 openclaw config get plugins.entries.openclaw-bridge --json \u590D\u6838\u3002";
+  const normalizedBefore = normalizeConfigForScopedDiff(before);
+  const normalizedAfter = normalizeConfigForScopedDiff(after);
+  const changedPaths = diffLeafPaths(normalizedBefore, normalizedAfter);
+  const agentsDelta = summarizeAgentsListDelta(before, after);
+  const bridgeChanged = JSON.stringify(getBridgeEntry(before)) !== JSON.stringify(getBridgeEntry(after));
+  const allowed = changedPaths.every(
+    (item) => item.startsWith("plugins.entries.openclaw-bridge") || item.startsWith("agents.list")
+  ) && bridgeChanged && agentsDelta.added === 1 && agentsDelta.existingUnchanged;
+  return JSON.stringify({
+    allowedOnboardingConfigChanged: allowed,
+    changedPaths,
+    bridgeChanged,
+    agentsList: agentsDelta
+  }, null, 2);
+}
+function normalizeConfigForScopedDiff(value) {
+  const clone = JSON.parse(JSON.stringify(value));
+  const meta = readRecord2(clone.meta) ? clone.meta : null;
+  if (meta) {
+    delete meta.lastTouchedAt;
+    if (Object.keys(meta).length === 0) {
+      delete clone.meta;
+    }
+  }
+  return clone;
+}
+function diffLeafPaths(before, after, prefix = "") {
+  if (JSON.stringify(before) === JSON.stringify(after)) {
+    return [];
+  }
+  if (!readRecord2(before) || !readRecord2(after)) {
+    return [prefix || "<root>"];
+  }
+  const keys = /* @__PURE__ */ new Set([...Object.keys(before), ...Object.keys(after)]);
+  return [...keys].flatMap((key) => diffLeafPaths(before[key], after[key], prefix ? `${prefix}.${key}` : key));
+}
+function summarizeAgentsListDelta(before, after) {
+  let beforeAgents = readAgentsList(before);
+  const afterAgents = readAgentsList(after);
+  if (beforeAgents.length === 0) {
+    const materializedMain = afterAgents.find((agent) => agent.id === "main");
+    if (materializedMain) {
+      beforeAgents = [materializedMain];
+    }
+  }
+  const beforeById = new Map(beforeAgents.map((agent) => [agent.id, agent]));
+  const afterById = new Map(afterAgents.map((agent) => [agent.id, agent]));
+  const added = afterAgents.filter((agent) => !beforeById.has(agent.id));
+  const removed = beforeAgents.filter((agent) => !afterById.has(agent.id));
+  const changedExisting = beforeAgents.filter((agent) => {
+    const next = afterById.get(agent.id);
+    return next ? JSON.stringify(agent) !== JSON.stringify(next) : false;
+  });
+  return {
+    before: beforeAgents.length,
+    after: afterAgents.length,
+    added: added.length,
+    addedIds: added.map((agent) => agent.id),
+    removedIds: removed.map((agent) => agent.id),
+    changedExistingIds: changedExisting.map((agent) => agent.id),
+    existingUnchanged: removed.length === 0 && changedExisting.length === 0
+  };
+}
+function readAgentsList(config) {
+  const agents = readRecord2(config.agents) ? config.agents : null;
+  const list = Array.isArray(agents?.list) ? agents.list : [];
+  return list.filter(readRecord2).map((agent) => ({
+    id: typeof agent.id === "string" ? agent.id : "",
+    name: typeof agent.name === "string" ? agent.name : void 0,
+    workspace: typeof agent.workspace === "string" ? agent.workspace : void 0,
+    agentDir: typeof agent.agentDir === "string" ? agent.agentDir : void 0,
+    model: typeof agent.model === "string" ? agent.model : void 0,
+    isDefault: agent.isDefault === true
+  })).filter((agent) => agent.id.length > 0);
+}
+function getBridgeEntry(value) {
+  return readNestedRecord(value, ["plugins", "entries", "openclaw-bridge"]);
+}
+async function readOptionalFile(filePath) {
+  try {
+    return await readFile2(filePath.replace(/^~(?=\/)/, process.env.HOME ?? ""), "utf8");
+  } catch {
+    return null;
+  }
+}
+async function readJsonFile(filePath) {
+  const raw = await readOptionalFile(filePath);
+  return raw ? parseJsonLoose(raw) : null;
+}
+function parseJsonLoose(value) {
+  try {
+    const parsed = JSON.parse(value);
+    return readRecord2(parsed) ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+function parseJsonFromMixedOutput(value) {
+  for (let index = 0; index < value.length; index += 1) {
+    if (value[index] !== "{" && value[index] !== "[") continue;
+    try {
+      return JSON.parse(value.slice(index));
+    } catch {
+    }
+  }
+  return null;
+}
+function lastPathLikeLine(value) {
+  const lines = value.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+  return lines.reverse().find((line) => line.startsWith("/") || line.startsWith("~")) ?? null;
+}
+function pickMainAgent(agents) {
+  return agents.find((agent) => agent.isDefault) ?? agents.find((agent) => agent.id === "main") ?? agents[0];
+}
+function readNestedRecord(value, keys) {
+  let current = value;
+  for (const key of keys) {
+    if (!readRecord2(current)) return null;
+    current = current[key];
+  }
+  return readRecord2(current) ? current : null;
+}
+function readRecord2(value) {
+  return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+function parseCsv(value) {
+  return value.split(",").map((item) => item.trim()).filter(Boolean);
+}
+function sanitizeId(value, separator = "-") {
+  const escaped = separator.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  return value.toLowerCase().replace(/[^a-z0-9._-]+/g, separator).replace(new RegExp(`^${escaped}+|${escaped}+$`, "g"), "") || "agt_community";
+}
+function sha256Json(value) {
+  return createHash("sha256").update(JSON.stringify(value)).digest("hex");
+}
+function parseArgs(argv) {
+  const args = {};
+  for (let index = 0; index < argv.length; index += 1) {
+    const arg = argv[index];
+    if (!arg.startsWith("--")) continue;
+    const key = arg.slice(2);
+    if (key === "help" || key === "yes" || key === "non-interactive" || key === "replace-existing" || key === "confirm-main-agent") {
+      args[key] = true;
+      continue;
+    }
+    const next = argv[index + 1];
+    if (next && !next.startsWith("--")) {
+      args[key] = next;
+      index += 1;
+    } else {
+      args[key] = true;
+    }
+  }
+  return args;
+}
+function printHelp() {
+  console.log(`politeia-connect
+
+Interactive, plugin-scoped onboarding for AgentComm Politeia Bridge.
+
+Usage:
+  politeia-connect
+
+Validation helper:
+  politeia-connect --non-interactive --yes \\
+    --nickname MiniClawBeta --token-env AGENTCOMM_INVITE_TOKEN \\
+    --gateway-url ws://127.0.0.1:19180/ws
+
+This command never runs openclaw setup/onboard/configure. It only uses:
+  openclaw agents list
+  openclaw agents add --non-interactive
+  openclaw config patch
+  openclaw config validate
+  openclaw gateway call communityBridge.doctor
+`);
+}
+main().catch((error) => {
+  console.error(error instanceof Error ? error.message : String(error));
+  process.exitCode = 1;
+});