@xfxstudio/claworld 2026.4.16-testing.1 → 2026.4.16-testing.2

package/src/openclaw/plugin/claworld-channel-plugin.js

@@ -0,0 +1,3499 @@
+import { randomUUID } from 'node:crypto';
+
+import {
+  applyRuntimeIdentity,
+  buildRuntimeAuthHeaders,
+  normalizeRuntimeRegistration,
+  resolveRuntimeAppToken,
+} from './account-identity.js';
+import {
+  claworldChannelConfigJsonSchema,
+  claworldChannelConfigSchema,
+  defaultClaworldAccountId,
+  inspectClaworldChannelAccount,
+  listClaworldAccountIds,
+  projectClaworldStatusAccount,
+  resolveClaworldChannelAccount,
+  resolveClaworldRuntimeConfig,
+  validateClaworldChannelConfig,
+} from './config-schema.js';
+import {
+  loadClaworldRuntimeBackup,
+  persistClaworldRuntimeBackup,
+} from './runtime-backup.js';
+import {
+  claworldOnboardingAdapter,
+  claworldSetupAdapter,
+} from './onboarding.js';
+import { createClaworldLifecycleManager } from './lifecycle.js';
+import { createClaworldRelayClient } from './relay-client.js';
+import { createRelayEventProtocol } from '../protocol/relay-event-protocol.js';
+import { createInboundSessionRouter } from '../runtime/inbound-session-router.js';
+import { createOutboundSessionBridge } from '../runtime/outbound-session-bridge.js';
+import { createCanonicalResultBuilder } from '../runtime/canonical-result-builder.js';
+import { createDemoSessionBootstrap } from '../runtime/demo-session-bootstrap.js';
+import {
+  broadcastModeratedWorld,
+  createModeratedWorld,
+  fetchOwnedWorlds,
+  manageModeratedWorld,
+} from '../runtime/world-moderation-helper.js';
+import {
+  fetchWorldMembership,
+  fetchWorldMemberships,
+  leaveWorldMembership,
+  updateWorldMembershipProfile,
+} from '../runtime/world-membership-helper.js';
+import { submitFeedbackReport } from '../runtime/feedback-helper.js';
+import {
+  buildWorldSelectionPrompt,
+  buildCandidateDeliverySummary,
+  buildPostSetupWorldDirectory,
+  fetchWorldCandidateFeed,
+  fetchWorldDetail,
+  joinWorld,
+  searchWorldMembers,
+  searchWorlds,
+  resolveWorldSelection,
+  resolveWorldSelectionFlow,
+} from '../runtime/product-shell-helper.js';
+import { extractBackendErrorContext } from '../runtime/backend-error-context.js';
+import { getClaworldRuntime } from './runtime.js';
+import {
+  CLAWORLD_PLUGIN_CURRENT_VERSION,
+} from '../plugin-version.js';
+import {
+  createRuntimeBoundaryError,
+  normalizeRuntimeBoundaryError,
+  serializeRuntimeBoundaryError,
+} from '../../lib/runtime-errors.js';
+import { PUBLIC_IDENTITY_STATUS } from '../../lib/public-identity.js';
+
+function normalizeRelayHttpBaseUrl(serverUrl) {
+  const parsed = new URL(serverUrl);
+  if (parsed.protocol === 'ws:') parsed.protocol = 'http:';
+  if (parsed.protocol === 'wss:') parsed.protocol = 'https:';
+  parsed.pathname = '';
+  parsed.search = '';
+  parsed.hash = '';
+  return parsed.toString().replace(/\/$/, '');
+}
+
+function normalizePluginOptionalText(value) {
+  const normalized = String(value ?? '').trim();
+  return normalized || null;
+}
+
+function requireClientMessageId(value = null) {
+  const normalized = normalizePluginOptionalText(value);
+  if (!normalized) {
+    throw new Error('claworld outbound clientMessageId is required for POST /v1/orchestration/messages');
+  }
+  return normalized;
+}
+
+function buildGeneratedClientMessageId() {
+  return `openclaw_manual_${randomUUID()}`;
+}
+
+const DEFAULT_RELAY_HTTP_TIMEOUT_MS = 15_000;
+
+function buildRelayAgentSummary(item = {}) {
+  const normalizedAgentId = normalizeClaworldText(item?.agentId, null);
+  return {
+    agentId: normalizedAgentId,
+    displayName: normalizeClaworldText(item?.displayName, null),
+    publicIdentity: item?.publicIdentity && typeof item.publicIdentity === 'object' ? item.publicIdentity : null,
+    discoverable: typeof item?.discoverable === 'boolean' ? item.discoverable : null,
+    contactable: typeof item?.contactable === 'boolean' ? item.contactable : null,
+    online: typeof item?.online === 'boolean' ? item.online : null,
+  };
+}
+
+function normalizeClaworldTarget(raw) {
+  if (typeof raw !== 'string') return undefined;
+  let value = raw.trim();
+  if (!value) return undefined;
+  value = value.replace(/^claworld:/i, '').replace(/^user:/i, '').trim();
+  return value || undefined;
+}
+
+function normalizeClaworldText(value, fallback = null) {
+  if (value == null) return fallback;
+  const normalized = String(value).trim();
+  return normalized || fallback;
+}
+
+function resolveNormalizedText(value, fallback = null) {
+  return normalizeClaworldText(value, fallback);
+}
+
+function isAgentScopedSessionKey(sessionKey) {
+  return /^agent:[^:]+:/i.test(String(sessionKey || ''));
+}
+
+function buildAgentScopedLocalSessionKey({ sessionKey, localAgentId } = {}) {
+  const normalizedSessionKey = resolveNormalizedText(sessionKey, null);
+  if (!normalizedSessionKey) return null;
+  if (isAgentScopedSessionKey(normalizedSessionKey)) {
+    return normalizedSessionKey;
+  }
+  const normalizedLocalAgentId = resolveNormalizedText(localAgentId, null);
+  if (!normalizedLocalAgentId) {
+    return normalizedSessionKey;
+  }
+  return `agent:${normalizedLocalAgentId}:${normalizedSessionKey}`;
+}
+
+function stripAgentScopedLocalSessionKey({ sessionKey, localAgentId } = {}) {
+  const normalizedSessionKey = resolveNormalizedText(sessionKey, null);
+  if (!normalizedSessionKey) return null;
+  const normalizedLocalAgentId = resolveNormalizedText(localAgentId, null);
+  if (!normalizedLocalAgentId) {
+    return normalizedSessionKey;
+  }
+  const prefix = `agent:${normalizedLocalAgentId}:`;
+  if (normalizedSessionKey.startsWith(prefix)) {
+    return normalizedSessionKey.slice(prefix.length) || null;
+  }
+  return normalizedSessionKey;
+}
+
+function normalizeLocalSessionKeyFields(record = null, { localAgentId = null } = {}) {
+  if (!record || typeof record !== 'object' || Array.isArray(record)) {
+    return record;
+  }
+  const nextRecord = { ...record };
+  const normalizedLocalSessionKey = buildAgentScopedLocalSessionKey({
+    sessionKey: resolveNormalizedText(record.localSessionKey, resolveNormalizedText(record.sessionKey, null)),
+    localAgentId,
+  });
+  if (normalizedLocalSessionKey) {
+    nextRecord.localSessionKey = normalizedLocalSessionKey;
+  }
+  return nextRecord;
+}
+
+function normalizeChatInboxPayloadSessionKeys(payload = null, { localAgentId = null } = {}) {
+  if (!payload || typeof payload !== 'object' || Array.isArray(payload)) {
+    return payload;
+  }
+  const nextPayload = { ...payload };
+  if (payload.filters && typeof payload.filters === 'object' && !Array.isArray(payload.filters)) {
+    const normalizedFilterLocalSessionKey = buildAgentScopedLocalSessionKey({
+      sessionKey: payload.filters.localSessionKey,
+      localAgentId,
+    });
+    nextPayload.filters = {
+      ...payload.filters,
+      ...(normalizedFilterLocalSessionKey ? { localSessionKey: normalizedFilterLocalSessionKey } : {}),
+    };
+  }
+  if (Array.isArray(payload.chats)) {
+    nextPayload.chats = payload.chats.map((chat) => normalizeLocalSessionKeyFields(chat, { localAgentId }));
+  }
+  if (payload.kickoff && typeof payload.kickoff === 'object' && !Array.isArray(payload.kickoff)) {
+    nextPayload.kickoff = normalizeLocalSessionKeyFields(payload.kickoff, { localAgentId });
+  }
+  if (payload.chat && typeof payload.chat === 'object' && !Array.isArray(payload.chat)) {
+    nextPayload.chat = normalizeLocalSessionKeyFields(payload.chat, { localAgentId });
+  }
+  return nextPayload;
+}
+
+function resolveRelaySessionKeyFromOutboundContext(outboundContext = {}) {
+  const metadata = outboundContext?.metadata && typeof outboundContext.metadata === 'object' && !Array.isArray(outboundContext.metadata)
+    ? outboundContext.metadata
+    : {};
+  return normalizeClaworldText(
+    outboundContext.relaySessionKey,
+    normalizeClaworldText(
+      outboundContext.RelaySessionKey,
+      normalizeClaworldText(
+        metadata.relaySessionKey,
+        normalizeClaworldText(
+          metadata.sessionKey,
+          normalizeClaworldText(
+            outboundContext.sessionKey,
+            normalizeClaworldText(outboundContext.SessionKey, null),
+          ),
+        ),
+      ),
+    ),
+  );
+}
+
+function normalizeClaworldInteger(value, fallback = null) {
+  const normalized = Number(value);
+  if (!Number.isFinite(normalized)) return fallback;
+  return Math.trunc(normalized);
+}
+
+function shouldAuthorizeBridgedCommand({ runtimeConfig = {}, incomingText }) {
+  if (runtimeConfig.testing?.allowBridgedCommandDispatch !== true) {
+    return false;
+  }
+  return typeof incomingText === 'string' && incomingText.trim().startsWith('/');
+}
+
+function normalizeUntrustedContextLines(value) {
+  if (Array.isArray(value)) {
+    return value
+      .map((entry) => resolveNormalizedText(entry, null))
+      .filter(Boolean);
+  }
+  const singleLine = resolveNormalizedText(value, null);
+  return singleLine ? [singleLine] : [];
+}
+
+function mergeUntrustedContextLines(...groups) {
+  const merged = [];
+  const seen = new Set();
+  for (const group of groups) {
+    for (const line of normalizeUntrustedContextLines(group)) {
+      if (seen.has(line)) continue;
+      seen.add(line);
+      merged.push(line);
+    }
+  }
+  return merged;
+}
+
+function parseBridgeTimestampMs(value) {
+  if (typeof value === 'number' && Number.isFinite(value)) return value;
+  if (typeof value !== 'string') return null;
+  const normalized = value.trim();
+  if (!normalized) return null;
+  const parsed = Date.parse(normalized);
+  return Number.isFinite(parsed) ? parsed : null;
+}
+
+function resolveBridgeDeliveryTimestampMs({ delivery = {}, metadata = {} } = {}) {
+  return parseBridgeTimestampMs(delivery?.createdAt)
+    || parseBridgeTimestampMs(delivery?.turnCreatedAt)
+    || parseBridgeTimestampMs(metadata?.createdAt)
+    || Date.now();
+}
+
+const CLAWORLD_RELAY_OPERATIONAL_NOTICE_PATTERNS = [
+  /^🧭\s*New session:\s+\S+/i,
+  /^🧹\s*Auto-compaction complete(?:\s*\(count \d+\))?\.$/i,
+  /^↪️\s*Model Fallback:/i,
+  /^↪️\s*Model Fallback cleared:/i,
+  /^⚠️\s*Agent failed before reply:/i,
+];
+
+// Older/runtime-variant OpenClaw hosts may surface provider/runtime failures as
+// plain final text without setting `isError`. Keep this fallback at the bridge
+// boundary so business logic never has to guess.
+const CLAWORLD_RELAY_RUNTIME_ERROR_PATTERNS = [
+  /^⚠️\s*Agent failed before reply:/i,
+  /^LLM request failed:/i,
+  /^LLM request timed out\./i,
+  /^LLM request unauthorized\./i,
+  /^The AI service is temporarily overloaded\./i,
+  /^The AI service returned an error\./i,
+  /^⚠️\s*API rate limit reached\./i,
+  /^⚠️\s*.+\s+returned a billing error\b/i,
+];
+
+const CLAWORLD_RELAY_OPERATIONAL_SUFFIX_PATTERNS = [
+  /^Usage:\s+.+\s+in\s+\/\s+.+\s+out(?:\s+·\s+est\s+.+)?$/i,
+];
+
+const CLAWORLD_RUNTIME_OUTPUT_PREVIEW_LIMIT = 3;
+
+function stripRelayOperationalSuffix(text) {
+  const lines = String(text || '').split('\n');
+  while (lines.length > 0) {
+    const lastLine = String(lines[lines.length - 1] || '').trim();
+    if (!lastLine) {
+      lines.pop();
+      continue;
+    }
+    if (!CLAWORLD_RELAY_OPERATIONAL_SUFFIX_PATTERNS.some((pattern) => pattern.test(lastLine))) {
+      break;
+    }
+    lines.pop();
+  }
+  return lines.join('\n').trim();
+}
+
+function classifyRelayContinuationText(text) {
+  const normalized = stripRelayOperationalSuffix(text);
+  if (!normalized) {
+    return {
+      text: '',
+      operationalNotice: Boolean(String(text || '').trim()),
+      runtimeError: false,
+    };
+  }
+  if (CLAWORLD_RELAY_OPERATIONAL_NOTICE_PATTERNS.some((pattern) => pattern.test(normalized))) {
+    return {
+      text: '',
+      operationalNotice: true,
+      runtimeError: false,
+    };
+  }
+  return {
+    text: normalized,
+    operationalNotice: false,
+    runtimeError: false,
+  };
+}
+
+function sanitizeRelayContinuationText(text) {
+  return classifyRelayContinuationText(text).text;
+}
+
+function classifyRelayContinuationPayload(payload = {}) {
+  const rawText = String(payload?.text ?? payload?.body ?? '').trim();
+  const normalized = stripRelayOperationalSuffix(rawText);
+  const textClassification = classifyRelayContinuationText(rawText);
+  const runtimeError = payload?.isError === true
+    || CLAWORLD_RELAY_RUNTIME_ERROR_PATTERNS.some((pattern) => pattern.test(normalized));
+  if (runtimeError) {
+    return {
+      text: '',
+      previewText: normalized,
+      operationalNotice: false,
+      runtimeError: true,
+      nonRenderable: true,
+    };
+  }
+  return {
+    text: textClassification.text,
+    previewText: normalized,
+    operationalNotice: textClassification.operationalNotice,
+    runtimeError: false,
+    nonRenderable: textClassification.operationalNotice,
+  };
+}
+
+function resolveRelaySilentReason(runtimeOutputSummary = {}, continuation = {}) {
+  const counts = runtimeOutputSummary?.counts || {};
+  if (Number(counts.runtimeErrorFinal || 0) > 0) {
+    return 'runtime_failed_before_reply';
+  }
+  if (Number(counts.operationalNotice || 0) > 0 && Number(counts.nonRenderableFinal || 0) === Number(counts.final || 0)) {
+    return 'operational_notice_only';
+  }
+  const normalizedSource = normalizePluginOptionalText(continuation?.source);
+  if (normalizedSource && normalizedSource !== 'none') {
+    return normalizedSource;
+  }
+  return 'no_renderable_reply';
+}
+
+function previewRuntimeOutputText(text, maxLength = 120) {
+  const normalized = String(text || '').replace(/\s+/g, ' ').trim();
+  if (!normalized) return '';
+  if (normalized.length <= maxLength) return normalized;
+  return `${normalized.slice(0, Math.max(0, maxLength - 1)).trimEnd()}...`;
+}
+
+function appendRuntimeOutputPreview(previews, text) {
+  const preview = previewRuntimeOutputText(text);
+  if (!preview) return;
+  if (previews.includes(preview)) return;
+  if (previews.length >= CLAWORLD_RUNTIME_OUTPUT_PREVIEW_LIMIT) return;
+  previews.push(preview);
+}
+
+function appendPartialContinuationChunk(currentText, chunk) {
+  const nextChunk = typeof chunk === 'string' ? chunk : '';
+  if (!nextChunk) return currentText;
+  const existing = typeof currentText === 'string' ? currentText : '';
+  if (!existing) return nextChunk;
+  if (nextChunk === existing) return existing;
+  if (nextChunk.startsWith(existing)) return nextChunk;
+  if (existing.endsWith(nextChunk)) return existing;
+  return `${existing}${nextChunk}`;
+}
+
+function buildRelayContinuationText({
+  finalTexts = [],
+  blockTexts = [],
+  partialText = '',
+  allowPartialFallback = false,
+} = {}) {
+  const sanitizedFinalTexts = finalTexts
+    .map((entry) => sanitizeRelayContinuationText(entry))
+    .filter(Boolean);
+  if (sanitizedFinalTexts.length > 0) {
+    return {
+      text: sanitizedFinalTexts.join('\n\n').trim(),
+      source: 'final',
+    };
+  }
+  const sanitizedBlockTexts = blockTexts
+    .map((entry) => sanitizeRelayContinuationText(entry))
+    .filter(Boolean);
+  if (sanitizedBlockTexts.length > 0) {
+    return {
+      text: sanitizedBlockTexts.join('\n').trim(),
+      source: 'block',
+    };
+  }
+  const sanitizedPartialText = allowPartialFallback
+    ? sanitizeRelayContinuationText(partialText)
+    : '';
+  if (sanitizedPartialText) {
+    return {
+      text: sanitizedPartialText,
+      source: 'partial',
+    };
+  }
+  return {
+    text: '',
+    source: 'none',
+  };
+}
+
+function isExactNoReplyToken(text) {
+  return String(text || '').trim() === 'NO_REPLY';
+}
+
+function resolveContinuationState(turnData = {}) {
+  const continuation = turnData?.continuation;
+  if (!continuation || typeof continuation !== 'object' || Array.isArray(continuation)) {
+    return { allowed: true, reason: null, roundStatus: null };
+  }
+  return {
+    allowed: continuation.allowed !== false,
+    reason: normalizeClaworldText(continuation.reason, null),
+    roundStatus: normalizeClaworldText(continuation.roundStatus, null),
+  };
+}
+
+function buildClaworldDirectoryEntries(config = {}, accountId = null) {
+  const accountIds = listClaworldAccountIds(config);
+  const currentAccountId = String(accountId || '').trim();
+  const entries = [];
+
+  for (const id of accountIds) {
+    const account = inspectClaworldChannelAccount(config, id);
+    if (!account?.enabled || !account?.configured) continue;
+    const normalizedId = String(account.accountId || id || '').trim();
+    const boundAgentId = normalizeClaworldText(account.relay?.agentId, null);
+    if (!normalizedId || !boundAgentId) continue;
+    if (currentAccountId && normalizedId === currentAccountId) continue;
+    entries.push({
+      id: boundAgentId,
+      name: normalizedId,
+      handle: normalizedId,
+      rank: 100,
+    });
+  }
+
+  const current = inspectClaworldChannelAccount(config, currentAccountId || null);
+  const defaultTargetAgentId = normalizeClaworldText(current?.relay?.defaultTargetAgentId, null);
+  if (defaultTargetAgentId) {
+    if (!entries.some((entry) => entry.id === defaultTargetAgentId)) {
+      entries.push({ id: defaultTargetAgentId, name: defaultTargetAgentId, handle: defaultTargetAgentId, rank: 50 });
+    }
+  }
+
+  return entries;
+}
+
+async function deliverRelayMessage({ runtimeConfig, to, text, fetchImpl, logger, outboundContext = {}, messagePayload = null }) {
+  const fromAgentId = runtimeConfig.relay?.agentId;
+  if (!fromAgentId) throw new Error('claworld relay.agentId is required for outbound send');
+
+  const targetAgentId = normalizeClaworldText(to, null);
+  if (!targetAgentId) throw new Error('claworld outbound targetAgentId is required');
+
+  const normalizedText = normalizeClaworldText(text, null);
+  const payload = messagePayload && typeof messagePayload === 'object'
+    ? { ...messagePayload }
+    : {};
+
+  if (!normalizeClaworldText(payload.text, null) && normalizedText) {
+    payload.text = normalizedText;
+  }
+  if (!normalizeClaworldText(payload.text, null)) {
+    throw new Error('claworld outbound text is required');
+  }
+  payload.source = normalizeClaworldText(payload.source, 'openclaw-claworld');
+  payload.accountId = normalizeClaworldText(payload.accountId, runtimeConfig.accountId);
+  const clientMessageId = normalizePluginOptionalText(
+    outboundContext.clientMessageId || outboundContext.metadata?.clientMessageId || null
+  ) || buildGeneratedClientMessageId();
+  const relaySessionKey = resolveRelaySessionKeyFromOutboundContext(outboundContext);
+
+  const baseUrl = normalizeRelayHttpBaseUrl(runtimeConfig.serverUrl);
+  const result = await fetchJson(fetchImpl, `${baseUrl}/v1/orchestration/messages`, {
+    method: 'POST',
+    headers: {
+      'content-type': 'application/json',
+      ...(runtimeConfig.apiKey ? { 'x-api-key': runtimeConfig.apiKey } : {}),
+      ...buildRuntimeAuthHeaders(runtimeConfig),
+    },
+    body: JSON.stringify({
+      fromAgentId,
+      targetAgentId,
+      clientMessageId,
+      payload,
+      conversation: {
+        conversationKey: outboundContext.conversationKey || outboundContext.metadata?.conversationKey || null,
+        worldId: outboundContext.worldId || outboundContext.metadata?.worldId || null,
+        scope: outboundContext.scope || outboundContext.metadata?.scope || null,
+        conversationId: outboundContext.conversationId || outboundContext.metadata?.conversationId || null,
+        threadId: outboundContext.threadId || outboundContext.metadata?.threadId || null,
+        sessionKey: relaySessionKey,
+      },
+    }),
+  });
+
+  if (!result.ok) {
+    logger.error?.('[claworld:outbound] message delivery failed', { status: result.status, body: result.body });
+    throw createRuntimeBoundaryError({
+      code: 'relay_message_delivery_failed',
+      category: 'transport',
+      status: result.status >= 500 ? 502 : result.status,
+      message: `claworld outbound failed: ${result.status}`,
+      publicMessage: 'claworld outbound message delivery failed',
+      recoverable: true,
+      context: {
+        accountId: runtimeConfig.accountId || null,
+        fromAgentId,
+        targetAgentId,
+        status: result.status,
+      },
+    });
+  }
+
+  return {
+    channel: 'claworld',
+    messageId: result.body?.turn?.turnId || `turn_${Date.now()}`,
+    chatId: targetAgentId,
+    timestamp: Date.now(),
+    meta: {
+      clientMessageId,
+      sessionKey: result.body?.delivery?.sessionKey || relaySessionKey,
+      turnId: result.body?.turn?.turnId || null,
+      conversationKey: result.body?.conversationKey || null,
+      targetAgentId,
+    },
+  };
+}
+
+function buildRelayJsonPath(pathname, query = {}) {
+  const search = new URLSearchParams();
+  Object.entries(query).forEach(([key, value]) => {
+    const normalized = resolveNormalizedText(value, null);
+    if (normalized) search.set(key, normalized);
+  });
+  const encoded = search.toString();
+  return encoded ? `${pathname}?${encoded}` : pathname;
+}
+
+function createRelayRouteError({
+  result,
+  runtimeConfig,
+  code,
+  publicMessage,
+  message,
+  context = {},
+}) {
+  throw createRuntimeBoundaryError({
+    code,
+    category: 'transport',
+    status: result?.status >= 500 ? 502 : result?.status || 502,
+    message: message || publicMessage,
+    publicMessage,
+    recoverable: true,
+    context: {
+      accountId: runtimeConfig.accountId || null,
+      httpStatus: result?.status || null,
+      ...extractBackendErrorContext(result?.body),
+      ...context,
+    },
+  });
+}
+
+async function createChatRequest({
+  runtimeConfig,
+  fromAgentId,
+  displayName = null,
+  agentCode = null,
+  openingMessage = null,
+  worldId = null,
+  requestContext = null,
+  fetchImpl,
+}) {
+  const normalizedDisplayName = normalizeClaworldText(displayName, null);
+  const normalizedAgentCode = normalizeClaworldText(agentCode, null)?.toUpperCase() || null;
+  if (!normalizedDisplayName || !normalizedAgentCode) {
+    throw createRuntimeBoundaryError({
+      code: 'tool_input_invalid',
+      category: 'input',
+      status: 400,
+      message: 'claworld chat request target requires displayName and agentCode',
+      publicMessage: 'claworld chat request target requires displayName and agentCode',
+      recoverable: true,
+      context: { fields: ['displayName', 'agentCode'] },
+    });
+  }
+  const baseUrl = normalizeRelayHttpBaseUrl(runtimeConfig.serverUrl);
+  const result = await fetchJson(fetchImpl, `${baseUrl}/v1/chat-requests`, {
+    method: 'POST',
+    headers: {
+      'content-type': 'application/json',
+      ...(runtimeConfig.apiKey ? { 'x-api-key': runtimeConfig.apiKey } : {}),
+      ...buildRuntimeAuthHeaders(runtimeConfig),
+    },
+    body: JSON.stringify({
+      fromAgentId,
+      displayName: normalizedDisplayName,
+      agentCode: normalizedAgentCode,
+      openingMessage: normalizeClaworldText(openingMessage, null),
+      ...(normalizeClaworldText(worldId, null) ? { worldId: normalizeClaworldText(worldId, null) } : {}),
+      ...(requestContext && typeof requestContext === 'object' && !Array.isArray(requestContext)
+        ? { requestContext }
+        : {}),
+    }),
+  });
+  if (!result.ok) {
+    createRelayRouteError({
+      result,
+      runtimeConfig,
+      code: 'chat_request_create_failed',
+      publicMessage: 'failed to create chat request',
+      context: {
+        fromAgentId,
+        displayName: normalizedDisplayName,
+        agentCode: normalizedAgentCode,
+      },
+    });
+  }
+  return result.body || {};
+}
+
+async function listChatInbox({
+  runtimeConfig,
+  agentId,
+  localAgentId = null,
+  filters = null,
+  direction = null,
+  fetchImpl,
+}) {
+  const normalizedFilters = filters && typeof filters === 'object' && !Array.isArray(filters)
+    ? filters
+    : {};
+  const relayLocalSessionKey = stripAgentScopedLocalSessionKey({
+    sessionKey: normalizedFilters.localSessionKey,
+    localAgentId,
+  });
+  const baseUrl = normalizeRelayHttpBaseUrl(runtimeConfig.serverUrl);
+  const path = buildRelayJsonPath('/v1/chat-requests', {
+    agentId,
+    direction: normalizedFilters.direction || direction,
+    mode: normalizedFilters.mode,
+    status: normalizedFilters.status,
+    worldId: normalizedFilters.worldId,
+    chatRequestId: normalizedFilters.chatRequestId,
+    conversationKey: normalizedFilters.conversationKey,
+    localSessionKey: relayLocalSessionKey,
+    counterpartyAgentId: normalizedFilters.counterpartyAgentId,
+  });
+  const result = await fetchJson(fetchImpl, `${baseUrl}${path}`, {
+    method: 'GET',
+    headers: {
+      ...(runtimeConfig.apiKey ? { 'x-api-key': runtimeConfig.apiKey } : {}),
+      ...buildRuntimeAuthHeaders(runtimeConfig),
+    },
+  });
+  if (!result.ok) {
+    createRelayRouteError({
+      result,
+      runtimeConfig,
+      code: 'chat_request_list_failed',
+      publicMessage: 'failed to list chat requests',
+      context: {
+        agentId,
+        direction: normalizedFilters.direction || direction,
+        mode: normalizedFilters.mode || null,
+        status: normalizedFilters.status || null,
+        worldId: normalizedFilters.worldId || null,
+        chatRequestId: normalizedFilters.chatRequestId || null,
+      },
+    });
+  }
+  return normalizeChatInboxPayloadSessionKeys(result.body || {}, { localAgentId });
+}
+
+async function acceptChatRequest({
+  runtimeConfig,
+  actorAgentId,
+  chatRequestId,
+  localAgentId = null,
+  fetchImpl,
+}) {
+  const baseUrl = normalizeRelayHttpBaseUrl(runtimeConfig.serverUrl);
+  const result = await fetchJson(fetchImpl, `${baseUrl}/v1/chat-requests/${encodeURIComponent(chatRequestId)}/accept`, {
+    method: 'POST',
+    headers: {
+      'content-type': 'application/json',
+      ...(runtimeConfig.apiKey ? { 'x-api-key': runtimeConfig.apiKey } : {}),
+      ...buildRuntimeAuthHeaders(runtimeConfig),
+    },
+    body: JSON.stringify({ actorAgentId }),
+  });
+  if (!result.ok) {
+    createRelayRouteError({
+      result,
+      runtimeConfig,
+      code: 'chat_request_accept_failed',
+      publicMessage: 'failed to accept chat request',
+      context: { actorAgentId, chatRequestId },
+    });
+  }
+  return normalizeChatInboxPayloadSessionKeys(result.body || {}, { localAgentId });
+}
+
+async function rejectChatRequest({
+  runtimeConfig,
+  actorAgentId,
+  chatRequestId,
+  fetchImpl,
+}) {
+  const baseUrl = normalizeRelayHttpBaseUrl(runtimeConfig.serverUrl);
+  const result = await fetchJson(fetchImpl, `${baseUrl}/v1/chat-requests/${encodeURIComponent(chatRequestId)}/reject`, {
+    method: 'POST',
+    headers: {
+      'content-type': 'application/json',
+      ...(runtimeConfig.apiKey ? { 'x-api-key': runtimeConfig.apiKey } : {}),
+      ...buildRuntimeAuthHeaders(runtimeConfig),
+    },
+    body: JSON.stringify({ actorAgentId }),
+  });
+  if (!result.ok) {
+    createRelayRouteError({
+      result,
+      runtimeConfig,
+      code: 'chat_request_reject_failed',
+      publicMessage: 'failed to reject chat request',
+      context: { actorAgentId, chatRequestId },
+    });
+  }
+  return result.body || {};
+}
+
+function waitForAbort(signal) {
+  return new Promise((resolve) => {
+    if (!signal) return resolve({ reason: 'missing_abort_signal' });
+    if (signal.aborted) return resolve({ reason: 'already_aborted' });
+    signal.addEventListener('abort', () => resolve({ reason: 'abort_signal' }), { once: true });
+  });
+}
+
+function waitForRelayClientClose(relayClient) {
+  return new Promise((resolve) => {
+    if (!relayClient?.once) return resolve({ reason: 'missing_relay_client' });
+    relayClient.once('close', (info = {}) => {
+      resolve({
+        reason: info.reason || 'relay_client_closed',
+        close: info,
+      });
+    });
+  });
+}
+
+function isNonRecoverableBootstrapHoldError(error) {
+  return Boolean(
+    error
+    && error.recoverable === false
+    && ['auth', 'bootstrap', 'config', 'conflict', 'input', 'policy'].includes(error.category),
+  );
+}
+
+function buildBootstrapHoldMessage(error, runtimeConfig = {}) {
+  const publicMessage = normalizeClaworldText(error?.publicMessage, null);
+  const fallbackMessage = normalizeClaworldText(error?.message, 'relay binding bootstrap failed');
+  return `Claworld setup blocked: ${publicMessage || fallbackMessage}`;
+}
+
+function summarizeObjectShape(value) {
+  if (!value || typeof value !== 'object') return { type: typeof value };
+  const keys = Object.keys(value).sort();
+  return {
+    type: Array.isArray(value) ? 'array' : 'object',
+    keys,
+    hasChannelsClaworld: Boolean(value.channels?.claworld),
+    hasAccounts: Boolean(value.accounts && typeof value.accounts === 'object'),
+    accountId: value.accountId || null,
+    configured: typeof value.configured === 'boolean' ? value.configured : null,
+  };
+}
+
+function hasRelayDispatchSurface(runtime) {
+  return Boolean(
+    runtime?.channel?.routing?.resolveAgentRoute
+    && runtime?.channel?.reply?.finalizeInboundContext
+    && (
+      runtime?.channel?.reply?.dispatchReplyFromConfig
+      || runtime?.channel?.reply?.createReplyDispatcherWithTyping
+    )
+  );
+}
+
+function resolvePluginRuntimeCandidate(contextRuntime) {
+  let globalRuntime = null;
+  try {
+    globalRuntime = getClaworldRuntime();
+  } catch {
+    globalRuntime = null;
+  }
+
+  if (hasRelayDispatchSurface(contextRuntime)) {
+    return {
+      runtime: contextRuntime,
+      runtimeSource: 'context.runtime',
+    };
+  }
+
+  if (hasRelayDispatchSurface(globalRuntime)) {
+    return {
+      runtime: globalRuntime,
+      runtimeSource: 'global_runtime',
+    };
+  }
+
+  if (contextRuntime) {
+    return {
+      runtime: contextRuntime,
+      runtimeSource: 'context.runtime',
+    };
+  }
+
+  if (globalRuntime) {
+    return {
+      runtime: globalRuntime,
+      runtimeSource: 'global_runtime',
+    };
+  }
+
+  return {
+    runtime: null,
+    runtimeSource: 'unavailable',
+  };
+}
+
+function resolveRuntimeConfigSource(context = {}) {
+  const runtimeCfg = context.cfg && typeof context.cfg === 'object' ? context.cfg : null;
+  const accountId = context.accountId || context.account?.accountId || null;
+
+  if (runtimeCfg) {
+    return {
+      sourceType: 'root_cfg',
+      configSource: runtimeCfg,
+      runtimeConfig: resolveClaworldRuntimeConfig(runtimeCfg, accountId),
+    };
+  }
+
+  const accountLike = context.account || context.config || null;
+  if (accountLike) {
+    return {
+      sourceType: 'resolved_account',
+      configSource: accountLike,
+      runtimeConfig: resolveClaworldRuntimeConfig(accountLike, accountId),
+    };
+  }
+
+  return {
+    sourceType: 'empty',
+    configSource: {},
+    runtimeConfig: resolveClaworldRuntimeConfig({}, accountId),
+  };
+}
+
+async function fetchJson(fetchImpl, url, init = {}) {
+  const timeoutMs = Number.isFinite(Number(init?.timeoutMs))
+    ? Math.max(1, Number(init.timeoutMs))
+    : DEFAULT_RELAY_HTTP_TIMEOUT_MS;
+  const controller = new AbortController();
+  const timeoutId = setTimeout(() => controller.abort(new Error('request_timeout')), timeoutMs);
+  if (typeof timeoutId?.unref === 'function') timeoutId.unref();
+  const requestInit = {
+    ...init,
+    signal: controller.signal,
+  };
+  delete requestInit.timeoutMs;
+  try {
+    const response = await fetchImpl(url, requestInit);
+    let body = null;
+    try {
+      body = await response.json();
+    } catch {
+      body = null;
+    }
+    return { ok: response.ok, status: response.status, body };
+  } catch (error) {
+    throw createRuntimeBoundaryError({
+      code: 'relay_fetch_failed',
+      category: 'transport',
+      status: 502,
+      message: `fetch failed: ${error?.message || String(error)}`,
+        publicMessage: 'relay fetch failed',
+        recoverable: true,
+        context: {
+          fetchUrl: url,
+          fetchMethod: requestInit.method || 'GET',
+          fetchHeaders: requestInit.headers || null,
+          timeoutMs,
+        },
+        cause: error,
+      });
+  } finally {
+    clearTimeout(timeoutId);
+  }
+}
+
+async function fetchPublicIdentity({
+  runtimeConfig,
+  agentId = null,
+  generateShareCard = false,
+  expiresInSeconds = null,
+  fetchImpl,
+}) {
+  if (!resolveRuntimeAppToken(runtimeConfig)) {
+    const recommendedDisplayName = normalizeClaworldText(
+      runtimeConfig?.name,
+      normalizeClaworldText(runtimeConfig?.registration?.displayName, null),
+    );
+    return {
+      status: 'pending',
+      agentId: normalizeClaworldText(agentId, null),
+      ready: false,
+      publicIdentity: {
+        status: PUBLIC_IDENTITY_STATUS.PENDING,
+        displayName: null,
+        code: null,
+        displayIdentity: null,
+        confirmedAt: null,
+        updatedAt: null,
+      },
+      recommendedDisplayName,
+      nextAction: 'set_public_identity',
+      requiredAction: 'set_public_identity',
+      nextTool: 'claworld_account',
+      missingFields: [
+        {
+          fieldId: 'displayName',
+          label: 'Public Name',
+          description: 'A public display name used in Claworld identity surfaces.',
+        },
+        {
+          fieldId: 'code',
+          label: 'Public Code',
+          description: 'A system-generated unique suffix used in the public identity.',
+        },
+      ],
+      feedbackSummary: {
+        totalLikesReceived: 0,
+        totalDislikesReceived: 0,
+        totalLikesGiven: 0,
+        totalDislikesGiven: 0,
+      },
+      profile: null,
+    };
+  }
+
+  const baseUrl = normalizeRelayHttpBaseUrl(runtimeConfig.serverUrl);
+  const result = await fetchJson(fetchImpl, `${baseUrl}/v1/profile`, {
+    method: 'POST',
+    headers: {
+      'content-type': 'application/json',
+      ...(runtimeConfig.apiKey ? { 'x-api-key': runtimeConfig.apiKey } : {}),
+      ...buildRuntimeAuthHeaders(runtimeConfig),
+    },
+    body: JSON.stringify({
+      accountId: runtimeConfig.accountId || null,
+      ...(agentId ? { agentId } : {}),
+      action: 'view',
+      ...(generateShareCard === true ? { generateShareCard: true } : {}),
+      ...(normalizeClaworldInteger(expiresInSeconds, null) > 0
+        ? { expiresInSeconds: normalizeClaworldInteger(expiresInSeconds, null) }
+        : {}),
+    }),
+  });
+  if (!result.ok) {
+    createRelayRouteError({
+      result,
+      runtimeConfig,
+      code: 'public_identity_fetch_failed',
+      publicMessage: 'failed to read public identity status',
+      context: { agentId: normalizeClaworldText(agentId, null) },
+    });
+  }
+  return result.body || {};
+}
+
+async function updatePublicIdentity({
+  runtimeConfig,
+  agentId = null,
+  displayName = null,
+  generateShareCard = true,
+  expiresInSeconds = null,
+  fetchImpl,
+}) {
+  const normalizedDisplayName = normalizeClaworldText(displayName, null);
+  if (!normalizedDisplayName) {
+    throw createRuntimeBoundaryError({
+      code: 'tool_input_invalid',
+      category: 'input',
+      status: 400,
+      message: 'claworld public identity update requires displayName',
+      publicMessage: 'claworld public identity update requires displayName',
+      recoverable: true,
+      context: { field: 'displayName' },
+    });
+  }
+  let resolvedRuntimeConfig = applyRuntimeIdentity(runtimeConfig);
+  let resolvedAgentId = normalizeClaworldText(agentId, normalizeClaworldText(resolvedRuntimeConfig?.relay?.agentId, null));
+
+  if (!resolveRuntimeAppToken(resolvedRuntimeConfig)) {
+    const baseUrl = normalizeRelayHttpBaseUrl(resolvedRuntimeConfig.serverUrl);
+    const activationResult = await fetchJson(fetchImpl, `${baseUrl}/v1/onboarding/activate`, {
+      method: 'POST',
+      headers: {
+        'content-type': 'application/json',
+        ...(resolvedRuntimeConfig.apiKey ? { 'x-api-key': resolvedRuntimeConfig.apiKey } : {}),
+        ...buildRuntimeAuthHeaders(resolvedRuntimeConfig),
+      },
+      body: JSON.stringify({
+        displayName: normalizedDisplayName,
+      }),
+    });
+    if (!activationResult.ok) {
+      createRelayRouteError({
+        result: activationResult,
+        runtimeConfig: resolvedRuntimeConfig,
+        code: 'claworld_activation_failed',
+        publicMessage: 'failed to activate Claworld account',
+      });
+    }
+    const activatedToken = normalizeClaworldText(activationResult.body?.appToken, null);
+    const activatedAgentId = normalizeClaworldText(activationResult.body?.agentId, null);
+    if (!activatedToken || !activatedAgentId) {
+      throw createRuntimeBoundaryError({
+        code: 'claworld_activation_failed',
+        category: 'runtime',
+        status: 502,
+        message: 'claworld activation did not return appToken and agentId',
+        publicMessage: 'failed to activate Claworld account',
+        recoverable: true,
+      });
+    }
+    resolvedRuntimeConfig = applyRuntimeIdentity(resolvedRuntimeConfig, {
+      appToken: activatedToken,
+      relay: {
+        ...(resolvedRuntimeConfig?.relay && typeof resolvedRuntimeConfig.relay === 'object' ? resolvedRuntimeConfig.relay : {}),
+        agentId: activatedAgentId,
+      },
+    });
+    resolvedAgentId = activatedAgentId;
+  }
+  const baseUrl = normalizeRelayHttpBaseUrl(runtimeConfig.serverUrl);
+  const result = await fetchJson(fetchImpl, `${baseUrl}/v1/profile`, {
+    method: 'POST',
+    headers: {
+      'content-type': 'application/json',
+      ...(resolvedRuntimeConfig.apiKey ? { 'x-api-key': resolvedRuntimeConfig.apiKey } : {}),
+      ...buildRuntimeAuthHeaders(resolvedRuntimeConfig),
+    },
+    body: JSON.stringify({
+      accountId: resolvedRuntimeConfig.accountId || null,
+      ...(resolvedAgentId ? { agentId: resolvedAgentId } : {}),
+      action: 'update_identity',
+      displayName: normalizedDisplayName,
+      ...(generateShareCard === true ? { generateShareCard: true } : {}),
+      ...(normalizeClaworldInteger(expiresInSeconds, null) > 0
+        ? { expiresInSeconds: normalizeClaworldInteger(expiresInSeconds, null) }
+        : {}),
+    }),
+  });
+  if (!result.ok) {
+    createRelayRouteError({
+      result,
+      runtimeConfig: resolvedRuntimeConfig,
+      code: 'public_identity_update_failed',
+      publicMessage: 'failed to update public identity',
+      context: {
+        agentId: resolvedAgentId,
+      },
+    });
+  }
+  return {
+    ...(result.body || {}),
+    runtimeActivation: !resolveRuntimeAppToken(runtimeConfig)
+      ? {
+          status: 'activated',
+          agentId: resolvedAgentId,
+        }
+      : null,
+    runtimeConfig: resolvedRuntimeConfig,
+  };
+}
+
+async function updateChatRequestApprovalPolicy({
+  runtimeConfig,
+  agentId = null,
+  chatRequestApprovalPolicy = null,
+  fetchImpl,
+}) {
+  if (!resolveRuntimeAppToken(runtimeConfig)) {
+    throw createRuntimeBoundaryError({
+      code: 'claworld_account_unactivated',
+      category: 'conflict',
+      status: 409,
+      message: 'claworld account must be activated before updating chat policy',
+      publicMessage: 'activate the Claworld account before changing chat policy',
+      recoverable: true,
+    });
+  }
+
+  const baseUrl = normalizeRelayHttpBaseUrl(runtimeConfig.serverUrl);
+  const result = await fetchJson(fetchImpl, `${baseUrl}/v1/profile`, {
+    method: 'POST',
+    headers: {
+      'content-type': 'application/json',
+      ...(runtimeConfig.apiKey ? { 'x-api-key': runtimeConfig.apiKey } : {}),
+      ...buildRuntimeAuthHeaders(runtimeConfig),
+    },
+    body: JSON.stringify({
+      accountId: runtimeConfig.accountId || null,
+      ...(agentId ? { agentId } : {}),
+      action: 'update_chat_policy',
+      chatRequestApprovalPolicy,
+    }),
+  });
+  if (!result.ok) {
+    createRelayRouteError({
+      result,
+      runtimeConfig,
+      code: 'chat_request_approval_policy_update_failed',
+      publicMessage: 'failed to update chat policy',
+      context: {
+        accountId: runtimeConfig.accountId || null,
+        agentId: normalizeClaworldText(agentId, null),
+      },
+    });
+  }
+  return result.body || {};
+}
+
+async function updateGlobalProfile({
+  runtimeConfig,
+  agentId = null,
+  profile = '',
+  fetchImpl,
+}) {
+  if (!resolveRuntimeAppToken(runtimeConfig)) {
+    throw createRuntimeBoundaryError({
+      code: 'claworld_account_unactivated',
+      category: 'conflict',
+      status: 409,
+      message: 'claworld account must be activated before updating profile',
+      publicMessage: 'activate the Claworld account before updating profile',
+      recoverable: true,
+    });
+  }
+
+  const baseUrl = normalizeRelayHttpBaseUrl(runtimeConfig.serverUrl);
+  const result = await fetchJson(fetchImpl, `${baseUrl}/v1/profile`, {
+    method: 'POST',
+    headers: {
+      'content-type': 'application/json',
+      ...(runtimeConfig.apiKey ? { 'x-api-key': runtimeConfig.apiKey } : {}),
+      ...buildRuntimeAuthHeaders(runtimeConfig),
+    },
+    body: JSON.stringify({
+      accountId: runtimeConfig.accountId || null,
+      ...(agentId ? { agentId } : {}),
+      action: 'update_profile',
+      profile,
+    }),
+  });
+  if (!result.ok) {
+    createRelayRouteError({
+      result,
+      runtimeConfig,
+      code: 'profile_update_failed',
+      publicMessage: 'failed to update profile',
+      context: {
+        accountId: runtimeConfig.accountId || null,
+        agentId: normalizeClaworldText(agentId, null),
+      },
+    });
+  }
+  return result.body || {};
+}
+
+async function fetchRelayAgents({ runtimeConfig, fetchImpl, logger }) {
+  if (typeof fetchImpl !== 'function') {
+    throw new Error('fetch is unavailable for relay agent lookup');
+  }
+
+  const baseUrl = normalizeRelayHttpBaseUrl(runtimeConfig.serverUrl);
+  const result = await fetchJson(fetchImpl, `${baseUrl}/v1/agents`, {
+    headers: {
+      accept: 'application/json',
+      ...(runtimeConfig.apiKey ? { 'x-api-key': runtimeConfig.apiKey } : {}),
+      ...buildRuntimeAuthHeaders(runtimeConfig),
+    },
+  });
+
+  if (!result.ok) {
+    logger.warn?.('[claworld:pairing] relay agent lookup failed', {
+      accountId: runtimeConfig.accountId || null,
+      status: result.status,
+      body: result.body,
+    });
+    throw new Error(`relay agent lookup failed: ${result.status}`);
+  }
+
+  return Array.isArray(result.body?.items) ? result.body.items : [];
+}
+
+async function resolveRelayAgentSummary({
+  runtimeConfig,
+  fetchImpl,
+  logger,
+  agentId = null,
+}) {
+  const normalizedAgentId = normalizeClaworldText(agentId, null);
+
+  try {
+    const items = await fetchRelayAgents({ runtimeConfig, fetchImpl, logger });
+    const match = items
+      .map((item) => buildRelayAgentSummary(item))
+      .find((item) => normalizedAgentId && item.agentId === normalizedAgentId) || null;
+
+    if (match) {
+      return {
+        ...match,
+        resolved: true,
+        resolutionSource: 'agentId',
+      };
+    }
+  } catch {
+    // Fallback below keeps pairing/send tools usable even when lookup fails.
+  }
+
+  return {
+    agentId: normalizedAgentId,
+    displayName: normalizeClaworldText(runtimeConfig.registration?.displayName, normalizeClaworldText(runtimeConfig.localAgent?.displayName, null)),
+    publicIdentity: null,
+    discoverable: null,
+    contactable: null,
+    online: null,
+    resolved: false,
+    resolutionSource: 'fallback',
+  };
+}
+
+async function fetchPostSetupWorldDirectory({ cfg, accountId, runtimeConfig, limit = null, sort = null, page = null, fetchImpl, logger }) {
+  if (typeof fetchImpl !== 'function') {
+    throw new Error('fetch is unavailable for claworld product-shell helper');
+  }
+
+  const resolvedRuntimeConfig = runtimeConfig || resolveClaworldRuntimeConfig(cfg || {}, accountId || null);
+  const baseUrl = normalizeRelayHttpBaseUrl(resolvedRuntimeConfig.serverUrl);
+  const requestUrl = new URL(`${baseUrl}/v1/worlds`);
+  if (limit != null) requestUrl.searchParams.set('limit', String(limit));
+  if (sort) requestUrl.searchParams.set('sort', String(sort));
+  if (page != null) requestUrl.searchParams.set('page', String(page));
+  const worlds = await fetchJson(fetchImpl, requestUrl.toString(), {
+    headers: {
+      accept: 'application/json',
+      ...(resolvedRuntimeConfig.apiKey ? { 'x-api-key': resolvedRuntimeConfig.apiKey } : {}),
+      ...buildRuntimeAuthHeaders(resolvedRuntimeConfig),
+    },
+  });
+
+  if (!worlds.ok) {
+    logger.error?.('[claworld:product-shell] world directory fetch failed', {
+      status: worlds.status,
+      accountId: resolvedRuntimeConfig.accountId || accountId || null,
+      body: worlds.body,
+    });
+    throw new Error(`claworld product-shell world fetch failed: ${worlds.status}`);
+  }
+
+  return buildPostSetupWorldDirectory(worlds.body, {
+    accountId: resolvedRuntimeConfig.accountId || accountId || null,
+  });
+}
+
+async function ensureRelayBinding({ runtimeConfig, fetchImpl, logger }) {
+  const normalizedRuntimeConfig = applyRuntimeIdentity(runtimeConfig);
+  const registration = normalizeRuntimeRegistration(normalizedRuntimeConfig);
+  const appToken = resolveRuntimeAppToken(normalizedRuntimeConfig);
+
+  if (appToken && normalizedRuntimeConfig.relay?.agentId) {
+    return {
+      runtimeConfig: normalizedRuntimeConfig,
+      bindingSource: 'configured_app_token',
+    };
+  }
+
+  if (appToken) {
+    const identityPayload = await fetchPublicIdentity({
+      runtimeConfig: normalizedRuntimeConfig,
+      agentId: null,
+      generateShareCard: false,
+      expiresInSeconds: null,
+      fetchImpl,
+    });
+    const resolvedAgentId = normalizeClaworldText(identityPayload?.agentId, null);
+    if (resolvedAgentId) {
+      return {
+        runtimeConfig: applyRuntimeIdentity(normalizedRuntimeConfig, { agentId: resolvedAgentId }),
+        bindingSource: 'configured_app_token',
+      };
+    }
+    logger.info?.('[claworld:bootstrap] configured credential is missing relay.agentId; waiting for a later authenticated account read or update');
+    return {
+      runtimeConfig: normalizedRuntimeConfig,
+      bindingSource: 'configured_app_token',
+    };
+  }
+
+  return {
+    runtimeConfig: normalizedRuntimeConfig,
+    bindingSource: registration.enabled ? 'registration_pending' : 'unbound',
+  };
+}
+
+function resolveDeliveryWorldId(delivery = {}) {
+  const metadata = delivery?.metadata && typeof delivery.metadata === 'object' && !Array.isArray(delivery.metadata)
+    ? delivery.metadata
+    : {};
+  return resolveNormalizedText(metadata.worldId, null) || null;
+}
+
+function buildDeliveryInboundEnvelope({
+  runtime,
+  currentCfg,
+  remoteIdentity,
+  incomingText,
+  contextText = null,
+  commandText = null,
+  timestamp = null,
+  deliveryId,
+  sessionKey,
+  localSessionKey = null,
+  worldId = null,
+  conversationKey = null,
+  untrustedContext = [],
+}) {
+  const envelopeOptions = runtime?.channel?.reply?.resolveEnvelopeFormatOptions
+    ? runtime.channel.reply.resolveEnvelopeFormatOptions(currentCfg)
+    : undefined;
+  const bodyText = [
+    String(contextText || '').trim(),
+    String(incomingText || '').trim(),
+  ].filter(Boolean).join('\n\n');
+  const remoteLabel = String(remoteIdentity || 'unknown-peer').trim() || 'unknown-peer';
+  const rawBody = String(incomingText || '').trim();
+  const normalizedCommandText = String(commandText || '').trim();
+  const commandBody = normalizedCommandText || rawBody;
+  const bodyForAgent = bodyText || rawBody;
+  const contextLines = mergeUntrustedContextLines([
+    `[claworld peer ${remoteLabel}]`,
+    ...(worldId ? [`[claworld world ${worldId}]`] : []),
+    ...(conversationKey ? [`[claworld conversation ${conversationKey}]`] : []),
+    ...(localSessionKey && localSessionKey !== sessionKey ? [`[claworld local session ${localSessionKey}]`] : []),
+    `[claworld relay session ${sessionKey}]`,
+    `[claworld delivery ${deliveryId}]`,
+  ], untrustedContext);
+  const envelopeTimestamp = Number.isFinite(timestamp) ? new Date(timestamp) : new Date();
+
+  if (runtime?.channel?.reply?.formatAgentEnvelope) {
+    return {
+      Body: runtime.channel.reply.formatAgentEnvelope({
+        channel: 'Claworld',
+        from: remoteLabel,
+        timestamp: envelopeTimestamp,
+        envelope: envelopeOptions,
+        body: bodyForAgent,
+      }),
+      RawBody: rawBody,
+      CommandBody: commandBody,
+      BodyForAgent: bodyForAgent,
+      BodyForCommands: commandBody,
+      UntrustedContext: contextLines,
+    };
+  }
+
+  return {
+    Body: `${remoteLabel}: ${bodyForAgent}`,
+    RawBody: rawBody,
+    CommandBody: commandBody,
+    BodyForAgent: bodyForAgent,
+    BodyForCommands: commandBody,
+    UntrustedContext: contextLines,
+  };
+}
+
+function createDeliveryReplyDispatcher({
+  runtime,
+  currentCfg,
+  relayClient,
+  deliveryId,
+  sessionKey,
+  localAgentId = null,
+  allowReply = true,
+  logger,
+  runtimeAccountId,
+}) {
+  const prefixContext = runtime?.channel?.reply?.createReplyPrefixContext
+    ? runtime.channel.reply.createReplyPrefixContext({ cfg: currentCfg, agentId: localAgentId || runtimeAccountId })
+    : { responsePrefix: '', responsePrefixContextProvider: () => ({}) };
+  const humanDelay = runtime?.channel?.reply?.resolveHumanDelayConfig
+    ? runtime.channel.reply.resolveHumanDelayConfig(currentCfg, localAgentId || runtimeAccountId)
+    : undefined;
+
+  let replied = false;
+  let keptSilent = false;
+  let suppressed = false;
+  let replyTransport = null;
+  let replyFallbackUsed = false;
+  let keptSilentTransport = null;
+  let keptSilentFallbackUsed = false;
+  const finalTexts = [];
+  const blockTexts = [];
+  let partialContinuationText = '';
+  const runtimeOutputSummary = {
+    counts: {
+      final: 0,
+      block: 0,
+      tool: 0,
+      partial: 0,
+      reasoning: 0,
+      toolStart: 0,
+      assistantMessageStart: 0,
+      reasoningEnd: 0,
+      compactionStart: 0,
+      compactionEnd: 0,
+      nonRenderableFinal: 0,
+      operationalNotice: 0,
+      runtimeErrorFinal: 0,
+    },
+    previews: {
+      final: [],
+      block: [],
+      tool: [],
+      partial: [],
+      reasoning: [],
+      operationalNotice: [],
+      runtimeErrorFinal: [],
+    },
+    relayContinuationSource: 'none',
+    relayContinuationPreview: null,
+  };
+
+  const recordRuntimePayload = (kind, payload = {}) => {
+    if (!Object.prototype.hasOwnProperty.call(runtimeOutputSummary.counts, kind)) return;
+    runtimeOutputSummary.counts[kind] += 1;
+    const text = String(payload?.text ?? payload?.body ?? '').trim();
+    if (kind === 'final') {
+      const classified = classifyRelayContinuationPayload(payload);
+      if (classified.text) {
+        finalTexts.push(classified.text);
+        appendRuntimeOutputPreview(runtimeOutputSummary.previews.final, classified.text);
+      }
+      if (classified.nonRenderable) {
+        runtimeOutputSummary.counts.nonRenderableFinal += 1;
+      }
+      if (classified.operationalNotice) {
+        runtimeOutputSummary.counts.operationalNotice += 1;
+        appendRuntimeOutputPreview(runtimeOutputSummary.previews.operationalNotice, classified.previewText || text);
+      }
+      if (classified.runtimeError) {
+        runtimeOutputSummary.counts.runtimeErrorFinal += 1;
+        appendRuntimeOutputPreview(runtimeOutputSummary.previews.runtimeErrorFinal, classified.previewText || text);
+      }
+      return;
+    }
+    if (kind === 'block') {
+      if (text) {
+        blockTexts.push(text);
+        appendRuntimeOutputPreview(runtimeOutputSummary.previews.block, text);
+      }
+      return;
+    }
+    if (kind === 'tool') {
+      appendRuntimeOutputPreview(runtimeOutputSummary.previews.tool, text);
+    }
+  };
+
+  const recordRuntimeTextEvent = (kind, text) => {
+    if (!Object.prototype.hasOwnProperty.call(runtimeOutputSummary.counts, kind)) return;
+    runtimeOutputSummary.counts[kind] += 1;
+    if (kind === 'partial') {
+      appendRuntimeOutputPreview(runtimeOutputSummary.previews.partial, text);
+      return;
+    }
+    if (kind === 'reasoning') {
+      appendRuntimeOutputPreview(runtimeOutputSummary.previews.reasoning, text);
+    }
+  };
+
+  const recordRuntimeLifecycle = (kind) => {
+    if (!Object.prototype.hasOwnProperty.call(runtimeOutputSummary.counts, kind)) return;
+    runtimeOutputSummary.counts[kind] += 1;
+  };
+
+  const submitRelayReply = async (replyText) => {
+    if (typeof relayClient?.submitDeliveryReply !== 'function') {
+      throw new Error('relay client does not support reply submission');
+    }
+    return await relayClient.submitDeliveryReply({
+      deliveryId,
+      sessionKey,
+      replyText,
+      source: 'openclaw-autochain',
+    });
+  };
+
+  const submitRelayKeptSilent = async (reason) => {
+    if (typeof relayClient?.submitDeliveryKeptSilent !== 'function') {
+      throw new Error('relay client does not support kept_silent submission');
+    }
+    return await relayClient.submitDeliveryKeptSilent({
+      deliveryId,
+      sessionKey,
+      reason,
+      source: 'openclaw-autochain',
+    });
+  };
+
+  const flushReply = async (text) => {
+    const normalized = String(text || '').trim();
+    if (!normalized || replied || suppressed) return false;
+    if (allowReply === false) {
+      suppressed = true;
+      return false;
+    }
+    const replyResult = await submitRelayReply(normalized);
+    replyTransport = replyResult?.transport || null;
+    replyFallbackUsed = replyResult?.fallbackUsed === true;
+    replied = true;
+    return true;
+  };
+
+  const flushKeptSilent = async (reason = null) => {
+    if (replied || keptSilent || suppressed) return false;
+    if (allowReply === false) {
+      suppressed = true;
+      return false;
+    }
+    const silentResult = await submitRelayKeptSilent(
+      normalizePluginOptionalText(reason) || 'no_renderable_reply',
+    );
+    keptSilentTransport = silentResult?.transport || null;
+    keptSilentFallbackUsed = silentResult?.fallbackUsed === true;
+    keptSilent = true;
+    return true;
+  };
+
+  const dispatchApi = runtime.channel.reply.createReplyDispatcherWithTyping({
+    responsePrefix: prefixContext.responsePrefix,
+    responsePrefixContextProvider: prefixContext.responsePrefixContextProvider,
+    humanDelay,
+    deliver: async (payload = {}, info = {}) => {
+      if (info?.kind === 'final') {
+        recordRuntimePayload('final', payload);
+        return;
+      }
+      if (info?.kind === 'block') {
+        recordRuntimePayload('block', payload);
+        return;
+      }
+      if (info?.kind === 'tool') {
+        recordRuntimePayload('tool', payload);
+      }
+    },
+    onError: (error, info) => {
+      logger.error?.(`[claworld:${runtimeAccountId}] delivery bridge dispatch error`, {
+        deliveryId,
+        sessionKey,
+        kind: info?.kind || null,
+        error: error?.message || String(error),
+      });
+    },
+  });
+
+  const markDispatchIdle = async () => {
+    await dispatchApi.dispatcher.waitForIdle?.();
+    if (!replied && !suppressed) {
+      const allowPartialFallback = (
+        runtimeOutputSummary.counts.final > 0
+        && finalTexts.length === 0
+        && blockTexts.length === 0
+        && runtimeOutputSummary.counts.nonRenderableFinal === 0
+      );
+      const safeContinuation = buildRelayContinuationText({
+        finalTexts,
+        blockTexts,
+        partialText: partialContinuationText,
+        allowPartialFallback,
+      });
+      runtimeOutputSummary.relayContinuationSource = safeContinuation.source;
+      runtimeOutputSummary.relayContinuationPreview = safeContinuation.text
+        ? previewRuntimeOutputText(safeContinuation.text)
+        : null;
+      if (safeContinuation.text && isExactNoReplyToken(safeContinuation.text)) {
+        runtimeOutputSummary.relayContinuationSource = 'no_reply_token';
+        runtimeOutputSummary.relayContinuationPreview = 'NO_REPLY';
+        await flushKeptSilent('no_reply_token');
+      } else if (safeContinuation.text) {
+        await flushReply(safeContinuation.text);
+      } else {
+        const silentReason = resolveRelaySilentReason(runtimeOutputSummary, safeContinuation);
+        if (runtimeOutputSummary.counts.runtimeErrorFinal > 0) {
+          logger.warn?.(`[claworld:${runtimeAccountId}] runtime produced non-renderable error finals; returning kept_silent`, {
+            deliveryId,
+            sessionKey,
+            localAgentId,
+            runtimeOutputSummary,
+          });
+        }
+        await flushKeptSilent(silentReason);
+      }
+    }
+    await dispatchApi.markDispatchIdle?.();
+  };
+
+  return {
+    dispatcher: dispatchApi.dispatcher,
+    replyOptions: {
+      ...dispatchApi.replyOptions,
+      onPartialReply: async (payload = {}) => {
+        partialContinuationText = appendPartialContinuationChunk(
+          partialContinuationText,
+          typeof payload?.text === 'string' ? payload.text : '',
+        );
+        recordRuntimeTextEvent('partial', payload?.text);
+      },
+      onReasoningStream: async (payload = {}) => {
+        recordRuntimeTextEvent('reasoning', payload?.text);
+      },
+      onReasoningEnd: async () => {
+        recordRuntimeLifecycle('reasoningEnd');
+      },
+      onAssistantMessageStart: async () => {
+        recordRuntimeLifecycle('assistantMessageStart');
+      },
+      onToolStart: async () => {
+        recordRuntimeLifecycle('toolStart');
+      },
+      onCompactionStart: async () => {
+        recordRuntimeLifecycle('compactionStart');
+      },
+      onCompactionEnd: async () => {
+        recordRuntimeLifecycle('compactionEnd');
+      },
+    },
+    markDispatchIdle,
+    didReply: () => replied,
+    didKeepSilent: () => keptSilent,
+    getRuntimeOutputSummary: () => ({
+      counts: { ...runtimeOutputSummary.counts },
+      previews: {
+        final: [...runtimeOutputSummary.previews.final],
+        block: [...runtimeOutputSummary.previews.block],
+        tool: [...runtimeOutputSummary.previews.tool],
+      partial: [...runtimeOutputSummary.previews.partial],
+      reasoning: [...runtimeOutputSummary.previews.reasoning],
+      operationalNotice: [...runtimeOutputSummary.previews.operationalNotice],
+      runtimeErrorFinal: [...runtimeOutputSummary.previews.runtimeErrorFinal],
+    },
+    relayContinuationSource: runtimeOutputSummary.relayContinuationSource,
+    relayContinuationPreview: runtimeOutputSummary.relayContinuationPreview,
+    replyTransport,
+      replyFallbackUsed,
+      keptSilentTransport,
+      keptSilentFallbackUsed,
+    }),
+  };
+}
+
+async function runDeliveryReplyDispatch({
+  runtime,
+  currentCfg,
+  relayClient,
+  deliveryId,
+  sessionKey,
+  localAgentId,
+  allowReply,
+  logger,
+  runtimeAccountId,
+  inboundCtx,
+} = {}) {
+  const {
+    dispatcher,
+    replyOptions,
+    markDispatchIdle,
+    didReply,
+    didKeepSilent,
+    getRuntimeOutputSummary,
+  } = createDeliveryReplyDispatcher({
+    runtime,
+    currentCfg,
+    relayClient,
+    deliveryId,
+    sessionKey,
+    localAgentId,
+    allowReply,
+    logger,
+    runtimeAccountId,
+  });
+
+  const dispatchResult = await runtime.channel.reply.dispatchReplyFromConfig({
+    ctx: inboundCtx,
+    cfg: currentCfg,
+    dispatcher,
+    replyOptions,
+  });
+  await markDispatchIdle();
+
+  return {
+    dispatchResult,
+    replied: didReply(),
+    keptSilent: didKeepSilent(),
+    runtimeOutputSummary: getRuntimeOutputSummary(),
+  };
+}
+
+function resolveBoundLocalAgentId({ cfg = {}, runtimeConfig = {}, relayClient } = {}) {
+  const accountId = resolveNormalizedText(runtimeConfig.accountId, null);
+  const bindings = Array.isArray(cfg?.bindings) ? cfg.bindings : [];
+  for (const rawBinding of bindings) {
+    const binding = rawBinding && typeof rawBinding === 'object' && !Array.isArray(rawBinding)
+      ? rawBinding
+      : {};
+    const match = binding.match && typeof binding.match === 'object' && !Array.isArray(binding.match)
+      ? binding.match
+      : {};
+    if (
+      resolveNormalizedText(match.channel, null) === 'claworld'
+      && resolveNormalizedText(match.accountId, null) === accountId
+      && resolveNormalizedText(binding.agentId, null)
+    ) {
+      return resolveNormalizedText(binding.agentId, null);
+    }
+  }
+
+  const agentList = Array.isArray(cfg?.agents?.list) ? cfg.agents.list : [];
+  if (agentList.length === 1) {
+    const onlyAgent = agentList[0] && typeof agentList[0] === 'object' && !Array.isArray(agentList[0])
+      ? agentList[0]
+      : {};
+    const onlyAgentId = resolveNormalizedText(onlyAgent.id, null);
+    if (onlyAgentId) {
+      return onlyAgentId;
+    }
+  }
+
+  return resolveNormalizedText(relayClient?.boundAgentId, null)
+    || resolveNormalizedText(runtimeConfig.agentId, null)
+    || 'main';
+}
+
+async function maybeBridgeRuntimeDelivery({
+  relayClient,
+  runtimeConfig,
+  runtimeAccountId,
+  event,
+  logger,
+  runtime,
+  cfg,
+  inbound,
+}) {
+  const delivery = event?.delivery && typeof event.delivery === 'object' && !Array.isArray(event.delivery)
+    ? event.delivery
+    : {};
+  const metadata = delivery.metadata && typeof delivery.metadata === 'object' && !Array.isArray(delivery.metadata)
+    ? delivery.metadata
+    : {};
+  const payload = delivery.payload && typeof delivery.payload === 'object' && !Array.isArray(delivery.payload)
+    ? delivery.payload
+    : {};
+  const deliveryId = resolveNormalizedText(delivery.deliveryId, null);
+  const sessionKey = resolveNormalizedText(delivery.sessionKey, null);
+  const contextText = resolveNormalizedText(payload.contextText, null);
+  const incomingText = resolveNormalizedText(
+    payload.commandText,
+    contextText ? null : resolveNormalizedText(payload.text, null),
+  );
+  const commandText = resolveNormalizedText(payload.commandText, incomingText);
+  const fromAgentId = resolveNormalizedText(metadata.fromAgentId, null);
+  const remoteIdentity = fromAgentId || 'unknown-peer';
+
+  if (
+    !runtime?.channel?.reply?.finalizeInboundContext
+    || !runtime?.channel?.reply?.dispatchReplyFromConfig
+    || !runtime?.channel?.reply?.createReplyDispatcherWithTyping
+  ) {
+    logger.warn?.(`[claworld:${runtimeAccountId}] skipping delivery bridge: missing runtime bridge hooks`, {
+      deliveryId,
+      sessionKey,
+    });
+    return { skipped: true, reason: 'missing_runtime_bridge_hooks' };
+  }
+  if (!deliveryId || !sessionKey || (!incomingText && !contextText)) {
+    logger.warn?.(`[claworld:${runtimeAccountId}] skipping delivery bridge: missing delivery payload`, {
+      deliveryId,
+      sessionKey,
+      hasIncomingText: Boolean(incomingText),
+      hasContextText: Boolean(contextText),
+    });
+    return { skipped: true, reason: 'missing_delivery_payload' };
+  }
+
+  const loadedCfg = await runtime.config?.loadConfig?.() || {};
+  const currentCfg = {
+    ...(loadedCfg && typeof loadedCfg === 'object' && !Array.isArray(loadedCfg) ? loadedCfg : {}),
+    ...(cfg && typeof cfg === 'object' && !Array.isArray(cfg) ? cfg : {}),
+    agents: cfg?.agents || loadedCfg?.agents,
+    bindings: cfg?.bindings || loadedCfg?.bindings,
+    channels: cfg?.channels || loadedCfg?.channels,
+    session: cfg?.session || loadedCfg?.session,
+  };
+  const localAgentId = resolveBoundLocalAgentId({
+    cfg: currentCfg,
+    runtimeConfig,
+    relayClient,
+  });
+  const localSessionKey = buildAgentScopedLocalSessionKey({
+    sessionKey,
+    localAgentId,
+  });
+  const routed = inbound?.routeInboundEvent?.(delivery, {
+    sessionTarget: runtimeConfig.routing?.sessionTarget,
+    fallbackTarget: runtimeConfig.routing?.fallbackTarget,
+  }) || null;
+  const worldId = resolveDeliveryWorldId(delivery);
+  const commandAuthorized = shouldAuthorizeBridgedCommand({
+    runtimeConfig,
+    incomingText: commandText || incomingText,
+  });
+  const inboundTimestamp = resolveBridgeDeliveryTimestampMs({ delivery, metadata });
+  const { Body, RawBody, CommandBody, BodyForAgent, BodyForCommands, UntrustedContext } = buildDeliveryInboundEnvelope({
+    runtime,
+    currentCfg,
+    remoteIdentity,
+    incomingText,
+    contextText,
+    commandText,
+    timestamp: inboundTimestamp,
+    deliveryId,
+    sessionKey,
+    localSessionKey,
+    worldId,
+    conversationKey: metadata.conversationKey || null,
+    untrustedContext: payload.untrustedContext,
+  });
+  const localIdentity = normalizeClaworldText(runtimeConfig.relay?.agentId, runtimeConfig.accountId);
+  const inboundCtx = runtime.channel.reply.finalizeInboundContext({
+    Body,
+    RawBody,
+    CommandBody,
+    BodyForAgent,
+    BodyForCommands,
+    From: `claworld:${remoteIdentity}`,
+    To: `claworld:${localIdentity}`,
+    SessionKey: localSessionKey || sessionKey,
+    RelaySessionKey: sessionKey,
+    AccountId: runtimeConfig.accountId,
+    OriginatingChannel: 'claworld',
+    OriginatingFrom: remoteIdentity,
+    OriginatingTo: remoteIdentity,
+    ChatType: 'direct',
+    SenderName: remoteIdentity,
+    SenderId: remoteIdentity,
+    MessageId: deliveryId,
+    Provider: 'claworld',
+    Surface: 'claworld',
+    ConversationLabel: remoteIdentity,
+    Timestamp: inboundTimestamp,
+    MessageSid: deliveryId,
+    WasMentioned: false,
+    CommandAuthorized: commandAuthorized,
+    RelayDeliveryId: deliveryId,
+    RelayFromAgentId: fromAgentId,
+    UntrustedContext,
+  });
+
+  if (runtime?.channel?.session?.recordInboundSession && runtime?.channel?.session?.resolveStorePath && localAgentId) {
+    const storePath = runtime.channel.session.resolveStorePath(currentCfg.session?.store, {
+      agentId: localAgentId,
+    });
+    await runtime.channel.session.recordInboundSession({
+      storePath,
+      sessionKey: inboundCtx.SessionKey || sessionKey,
+      ctx: inboundCtx,
+      onRecordError: (error) => {
+        logger.error?.(`[claworld:${runtimeAccountId}] failed to record inbound session`, {
+          deliveryId,
+          sessionKey,
+          localSessionKey,
+          localAgentId,
+          error: error?.message || String(error),
+        });
+      },
+    });
+  }
+
+  logger.info?.(`[claworld:${runtimeAccountId}] routing delivery into runtime session`, {
+    deliveryId,
+    sessionKey,
+    localSessionKey,
+    localAgentId,
+    remoteIdentity,
+    routeStatus: routed?.status || null,
+    bodyPreview: String(Body || '').slice(0, 240),
+    rawBodyPreview: String(RawBody || '').slice(0, 240),
+    allowReply: metadata.allowReply !== false,
+    commandAuthorized,
+  });
+
+  try {
+    const acceptedResult = await relayClient.acceptDeliveryHttp({
+      deliveryId,
+      sessionKey,
+      source: 'runtime_dispatch',
+    });
+    if (acceptedResult.status < 200 || acceptedResult.status >= 300) {
+      throw new Error(`failed to submit relay delivery acceptance: ${acceptedResult.status}`);
+    }
+  } catch (error) {
+    logger.warn?.(`[claworld:${runtimeAccountId}] delivery acceptance acknowledgement failed`, {
+      deliveryId,
+      sessionKey,
+      localSessionKey,
+      localAgentId,
+      error: error?.message || String(error),
+    });
+  }
+
+  let {
+    dispatchResult,
+    replied,
+    keptSilent,
+    runtimeOutputSummary,
+  } = await runDeliveryReplyDispatch({
+    runtime,
+    currentCfg,
+    relayClient,
+    deliveryId,
+    sessionKey,
+    localAgentId,
+    allowReply: metadata.allowReply !== false,
+    logger,
+    runtimeAccountId,
+    inboundCtx,
+  });
+
+  const shouldRetryKickoffDispatch = (
+    metadata.deliveryType === 'kickoff'
+    && metadata.allowReply !== false
+    && replied !== true
+    && runtimeOutputSummary.counts.final > 0
+    && runtimeOutputSummary.counts.nonRenderableFinal > 0
+    && runtimeOutputSummary.counts.final === runtimeOutputSummary.counts.nonRenderableFinal
+    && runtimeOutputSummary.counts.block === 0
+    && runtimeOutputSummary.counts.tool === 0
+    && runtimeOutputSummary.counts.partial === 0
+    && runtimeOutputSummary.counts.reasoning === 0
+    && runtimeOutputSummary.counts.toolStart === 0
+    && runtimeOutputSummary.counts.assistantMessageStart === 0
+    && runtimeOutputSummary.counts.reasoningEnd === 0
+    && runtimeOutputSummary.counts.compactionStart === 0
+    && runtimeOutputSummary.counts.compactionEnd === 0
+  );
+
+  if (shouldRetryKickoffDispatch) {
+    logger.warn?.(`[claworld:${runtimeAccountId}] kickoff delivery produced only operational notices; retrying dispatch once`, {
+      deliveryId,
+      sessionKey,
+      localSessionKey,
+      localAgentId,
+      runtimeOutputSummary,
+    });
+
+    ({
+      dispatchResult,
+      replied,
+      keptSilent,
+      runtimeOutputSummary,
+    } = await runDeliveryReplyDispatch({
+      runtime,
+      currentCfg,
+      relayClient,
+      deliveryId,
+      sessionKey,
+      localAgentId,
+      allowReply: metadata.allowReply !== false,
+      logger,
+      runtimeAccountId,
+      inboundCtx,
+    }));
+  }
+
+  logger.info?.(`[claworld:${runtimeAccountId}] delivery bridge completed`, {
+    deliveryId,
+    sessionKey,
+    localSessionKey,
+    queuedFinal: Boolean(dispatchResult?.queuedFinal),
+    replied,
+    keptSilent,
+    routeStatus: routed?.status || null,
+    runtimeOutputSummary,
+  });
+
+  return {
+    skipped: false,
+    ok: true,
+    replied,
+    keptSilent,
+    queuedFinal: Boolean(dispatchResult?.queuedFinal),
+    sessionKey,
+    localSessionKey,
+    routeStatus: routed?.status || null,
+  };
+}
+
+export function createClaworldChannelPlugin({
+  logger = console,
+  relayClientFactory = createClaworldRelayClient,
+  fetchImpl = globalThis.fetch?.bind(globalThis),
+} = {}) {
+  const protocol = createRelayEventProtocol();
+  const inbound = createInboundSessionRouter();
+  const outbound = createOutboundSessionBridge();
+  const results = createCanonicalResultBuilder();
+  const demo = createDemoSessionBootstrap();
+  const relayClients = new Map();
+  const lifecycles = new Map();
+  const accountRuntimeContexts = new Map();
+  const accountBindingStates = new Map();
+
+  function resolveAccountBindingKey(runtimeConfig = {}, fallbackAccountId = 'default') {
+    return String(runtimeConfig?.accountId || fallbackAccountId || 'default');
+  }
+
+  function mergeBoundRuntimeConfig(currentRuntimeConfig = {}, boundRuntimeConfig = {}) {
+    return applyRuntimeIdentity({
+      ...currentRuntimeConfig,
+      ...boundRuntimeConfig,
+      relay: {
+        ...(currentRuntimeConfig?.relay && typeof currentRuntimeConfig.relay === 'object' ? currentRuntimeConfig.relay : {}),
+        ...(boundRuntimeConfig?.relay && typeof boundRuntimeConfig.relay === 'object' ? boundRuntimeConfig.relay : {}),
+      },
+    });
+  }
+
+  function rememberAccountBinding({ runtimeConfig, accountId = null, bindingSource = 'binding_cache', relayAgent = null }) {
+    const normalizedRuntimeConfig = applyRuntimeIdentity(runtimeConfig);
+    const accountKey = resolveAccountBindingKey(normalizedRuntimeConfig, accountId || null);
+    accountBindingStates.set(accountKey, {
+      binding: {
+        runtimeConfig: normalizedRuntimeConfig,
+        bindingSource,
+        ...(relayAgent ? { relayAgent } : {}),
+      },
+    });
+  }
+
+  async function ensureAccountRelayBinding({ runtimeConfig, accountId = null }) {
+    const normalizedRuntimeConfig = applyRuntimeIdentity(runtimeConfig);
+    const accountKey = resolveAccountBindingKey(normalizedRuntimeConfig, accountId || null);
+    const cachedState = accountBindingStates.get(accountKey) || null;
+    const cachedBinding = cachedState?.binding || null;
+
+    if (
+      cachedBinding
+      && cachedBinding.runtimeConfig?.serverUrl
+      && cachedBinding.runtimeConfig.serverUrl === normalizedRuntimeConfig.serverUrl
+    ) {
+      return {
+        ...cachedBinding,
+        runtimeConfig: mergeBoundRuntimeConfig(normalizedRuntimeConfig, cachedBinding.runtimeConfig),
+        bindingSource: cachedBinding.bindingSource === 'configured_app_token'
+          ? 'configured_app_token'
+          : 'binding_cache',
+      };
+    }
+
+    if (cachedState?.promise) {
+      return cachedState.promise;
+    }
+
+    const promise = ensureRelayBinding({
+      runtimeConfig: normalizedRuntimeConfig,
+      fetchImpl,
+      logger,
+    }).then((binding) => {
+      const resolvedBinding = {
+        ...binding,
+        runtimeConfig: mergeBoundRuntimeConfig(normalizedRuntimeConfig, binding.runtimeConfig),
+      };
+      accountBindingStates.set(accountKey, { binding: resolvedBinding });
+      return resolvedBinding;
+    }).catch((error) => {
+      const latest = accountBindingStates.get(accountKey) || null;
+      if (latest?.promise === promise) {
+        accountBindingStates.delete(accountKey);
+      }
+      throw error;
+    });
+
+    accountBindingStates.set(accountKey, { promise });
+    return promise;
+  }
+
+  async function persistRuntimeAppToken({ runtime, accountId, appToken, relayAgentId = null }) {
+    if (!accountId || !appToken) {
+      return { skipped: true, reason: 'missing_account_or_token' };
+    }
+
+    let configPersistResult = { skipped: true, reason: 'missing_runtime_config_io' };
+    if (runtime?.config?.loadConfig && runtime?.config?.writeConfigFile) {
+      const currentCfg = await runtime.config.loadConfig();
+      const nextCfg = JSON.parse(JSON.stringify(currentCfg || {}));
+      nextCfg.channels = nextCfg.channels && typeof nextCfg.channels === 'object' && !Array.isArray(nextCfg.channels)
+        ? nextCfg.channels
+        : {};
+      const claworldRoot = nextCfg.channels.claworld && typeof nextCfg.channels.claworld === 'object' && !Array.isArray(nextCfg.channels.claworld)
+        ? nextCfg.channels.claworld
+        : {};
+      const accounts = claworldRoot.accounts && typeof claworldRoot.accounts === 'object' && !Array.isArray(claworldRoot.accounts)
+        ? claworldRoot.accounts
+        : {};
+      const account = accounts[accountId] && typeof accounts[accountId] === 'object' && !Array.isArray(accounts[accountId])
+        ? accounts[accountId]
+        : {};
+
+      const normalizedRelayAgentId = normalizeClaworldText(relayAgentId, normalizeClaworldText(account?.relay?.agentId, null));
+      const currentAppToken = normalizeClaworldText(account.appToken, null);
+      const currentRelayAgentId = normalizeClaworldText(account?.relay?.agentId, null);
+      if (currentAppToken === appToken && currentRelayAgentId === normalizedRelayAgentId) {
+        configPersistResult = { skipped: true, reason: 'already_persisted' };
+      } else {
+        accounts[accountId] = {
+          ...account,
+          appToken,
+          relay: {
+            ...(account?.relay && typeof account.relay === 'object' && !Array.isArray(account.relay) ? account.relay : {}),
+            ...(normalizedRelayAgentId ? { agentId: normalizedRelayAgentId } : {}),
+          },
+        };
+        delete accounts[accountId].registration;
+        claworldRoot.accounts = accounts;
+        nextCfg.channels.claworld = claworldRoot;
+        await runtime.config.writeConfigFile(nextCfg);
+        configPersistResult = { skipped: false, ok: true };
+      }
+    }
+
+    let backupPersistResult = { skipped: true, reason: 'missing_runtime_config_loader' };
+    try {
+      backupPersistResult = await persistClaworldRuntimeBackup({
+        runtime,
+        accountId,
+      });
+    } catch (error) {
+      backupPersistResult = {
+        skipped: true,
+        reason: 'backup_persist_failed',
+        error: error?.message || String(error),
+      };
+    }
+
+    return {
+      ...configPersistResult,
+      backup: backupPersistResult,
+    };
+  }
+
+  async function maybeRestoreRuntimeAppToken({ runtime, accountId, runtimeConfig }) {
+    if (resolveRuntimeAppToken(runtimeConfig)) {
+      return { restored: false, reason: 'already_configured', runtimeConfig };
+    }
+
+    const backupState = await loadClaworldRuntimeBackup({ accountId });
+    const backup = backupState.backup;
+    const backupToken = normalizeClaworldText(backup?.appToken, null);
+    if (!backupToken) {
+      return {
+        restored: false,
+        reason: 'backup_missing_app_token',
+        runtimeConfig,
+      };
+    }
+
+    const backupServerUrl = normalizeClaworldText(backup?.serverUrl, null);
+    const currentServerUrl = normalizeClaworldText(runtimeConfig?.serverUrl, null);
+    if (backupServerUrl && currentServerUrl && normalizeRelayHttpBaseUrl(backupServerUrl) !== normalizeRelayHttpBaseUrl(currentServerUrl)) {
+      return {
+        restored: false,
+        reason: 'backup_server_mismatch',
+        runtimeConfig,
+      };
+    }
+
+    const restoredRuntimeConfig = applyRuntimeIdentity(runtimeConfig, {
+      appToken: backupToken,
+    });
+
+    try {
+      await persistRuntimeAppToken({
+        runtime,
+        accountId,
+        appToken: backupToken,
+      });
+    } catch (error) {
+      logger.warn?.(`[claworld:${accountId || 'default'}] failed to persist restored runtime appToken`, {
+        error: error?.message || String(error),
+      });
+    }
+
+    return {
+      restored: true,
+      reason: 'installer_state_backup',
+      runtimeConfig: restoredRuntimeConfig,
+      backup,
+      installerStatePath: backupState.installerStatePath,
+    };
+  }
+
+  function resolveConfiguredRuntimeContext(context = {}) {
+    const cfg = context.cfg || {};
+    const accountId = context.accountId || null;
+    const runtimeContext = accountRuntimeContexts.get(accountId || 'default') || null;
+    const runtimeConfig = runtimeContext?.runtimeConfig || context.runtimeConfig || resolveClaworldRuntimeConfig(cfg, accountId);
+    return {
+      ...context,
+      cfg: runtimeContext?.cfg || cfg,
+      accountId: runtimeConfig.accountId || accountId || null,
+      runtimeConfig,
+      agentId: context.agentId || runtimeConfig.relay?.agentId || null,
+      bindingSource: runtimeContext?.deferredFailure ? 'runtime_context_deferred' : 'runtime_context',
+    };
+  }
+
+  async function resolveBoundRuntimeContext(context = {}) {
+    const configuredContext = resolveConfiguredRuntimeContext(context);
+    const cfg = configuredContext.cfg || {};
+    const accountId = configuredContext.accountId || null;
+    let runtimeConfig = configuredContext.runtimeConfig;
+    const runtimeResolution = resolvePluginRuntimeCandidate(context.runtime || null);
+    const restoredBinding = await maybeRestoreRuntimeAppToken({
+      runtime: runtimeResolution.runtime,
+      accountId,
+      runtimeConfig,
+    });
+    if (restoredBinding.restored) {
+      runtimeConfig = restoredBinding.runtimeConfig;
+      logger.info?.(`[claworld:${accountId || 'default'}] restored runtime binding from installer state`, {
+        installerStatePath: restoredBinding.installerStatePath || null,
+        relayAgentId: runtimeConfig?.relay?.agentId || null,
+      });
+    }
+    const runtimeContext = accountRuntimeContexts.get(accountId || 'default') || null;
+    if (runtimeContext?.runtimeConfig && !runtimeContext?.deferredFailure) {
+      return {
+        ...configuredContext,
+        cfg: runtimeContext.cfg || cfg,
+        accountId: runtimeConfig.accountId || accountId || null,
+        runtimeConfig,
+        agentId: configuredContext.agentId || runtimeConfig.relay?.agentId || null,
+        bindingSource: 'runtime_context',
+      };
+    }
+    const binding = await ensureAccountRelayBinding({ runtimeConfig, accountId });
+    runtimeConfig = binding.runtimeConfig;
+    return {
+      ...configuredContext,
+      cfg,
+      accountId: runtimeConfig.accountId || accountId || null,
+      runtimeConfig,
+      agentId: configuredContext.agentId || runtimeConfig.relay?.agentId || null,
+      bindingSource: binding.bindingSource,
+    };
+  }
+
+  function resolveContextBoundLocalAgentId(context = {}) {
+    return resolveBoundLocalAgentId({
+      cfg: context.cfg || {},
+      runtimeConfig: context.runtimeConfig || {},
+      relayClient: relayClients.get(context.accountId || 'default') || null,
+    });
+  }
+
+  function getAccountLifecycle(accountKey = 'default') {
+    if (lifecycles.has(accountKey)) return lifecycles.get(accountKey);
+
+    const lifecycle = createClaworldLifecycleManager({
+      logger,
+      connect: async (context = {}) => {
+        const runtimeAccountId = String(context.accountId || context.account?.accountId || accountKey);
+
+        logger.info?.(`[claworld:${runtimeAccountId}] startAccount invoked`, {
+          accountId: context.accountId || null,
+          hasAbortSignal: Boolean(context.abortSignal),
+          hasAccount: Boolean(context.account),
+          hasConfig: Boolean(context.config),
+          hasCfg: Boolean(context.cfg),
+          accountShape: summarizeObjectShape(context.account),
+          configShape: summarizeObjectShape(context.config),
+          cfgShape: summarizeObjectShape(context.cfg),
+        });
+
+        const { sourceType, configSource, runtimeConfig: initialRuntimeConfig } = resolveRuntimeConfigSource(context);
+        let runtimeConfig = initialRuntimeConfig;
+        logger.info?.(`[claworld:${runtimeAccountId}] resolved runtime config source`, {
+          sourceType,
+          configSourceShape: summarizeObjectShape(configSource),
+          runtimeConfigShape: summarizeObjectShape(runtimeConfig),
+        });
+
+        const runtimeResolution = resolvePluginRuntimeCandidate(context.runtime || null);
+        const restoredBinding = await maybeRestoreRuntimeAppToken({
+          runtime: runtimeResolution.runtime,
+          accountId: runtimeAccountId,
+          runtimeConfig,
+        });
+        if (restoredBinding.restored) {
+          runtimeConfig = restoredBinding.runtimeConfig;
+          logger.info?.(`[claworld:${runtimeAccountId}] restored runtime binding from installer state`, {
+            installerStatePath: restoredBinding.installerStatePath || null,
+            relayAgentId: runtimeConfig?.relay?.agentId || null,
+          });
+        }
+
+        const validation = validateClaworldChannelConfig(configSource, context.accountId);
+        if (!validation.ok && sourceType !== 'root_cfg') {
+          logger.warn?.(`[claworld:${runtimeAccountId}] non-root runtime source would not validate as full cfg`, {
+            sourceType,
+            errors: validation.errors,
+          });
+        }
+
+        let binding;
+        try {
+          binding = await ensureAccountRelayBinding({ runtimeConfig, accountId: runtimeAccountId });
+        } catch (error) {
+          const normalized = normalizeRuntimeBoundaryError(error, {
+            code: 'claworld_relay_binding_failed',
+            category: 'bootstrap',
+            message: 'claworld relay binding bootstrap failed',
+            publicMessage: 'claworld relay binding bootstrap failed',
+            recoverable: true,
+            context: {
+              accountId: runtimeAccountId,
+              stage: 'ensureRelayBinding',
+            },
+          });
+          if (!isNonRecoverableBootstrapHoldError(normalized)) {
+            throw normalized;
+          }
+
+          const { runtime: deferredRuntime } = resolvePluginRuntimeCandidate(context.runtime || null);
+          const deferredFailure = serializeRuntimeBoundaryError(normalized);
+          const holdMessage = buildBootstrapHoldMessage(normalized, runtimeConfig);
+          accountRuntimeContexts.set(accountKey, {
+            runtime: deferredRuntime,
+            cfg: context.cfg || null,
+            runtimeConfig,
+            deferredFailure,
+            deferredErrorMessage: holdMessage,
+          });
+          context.setStatus?.({
+            accountId: runtimeAccountId,
+            configured: false,
+            connected: false,
+            running: false,
+            restartPending: false,
+            lastError: holdMessage,
+          });
+          logger.warn?.(`[claworld:${runtimeAccountId}] relay binding requires operator setup; holding runtime`, {
+            code: normalized.code,
+            category: normalized.category,
+            status: normalized.status,
+            requestedAgentCode: normalized.context?.requestedAgentCode || null,
+          });
+          return {
+            startedDeferred: true,
+            reason: 'bootstrap_setup_required',
+            runtimeConfig,
+            deferredFailure,
+          };
+        }
+        runtimeConfig = binding.runtimeConfig;
+        logger.info?.(`[claworld:${runtimeAccountId}] relay binding ready`, {
+          bindingSource: binding.bindingSource,
+          relayAgentId: runtimeConfig.relay?.agentId || null,
+          hasAppToken: Boolean(resolveRuntimeAppToken(runtimeConfig)),
+        });
+
+        const relayAgentId = context.agentId || runtimeConfig.relay?.agentId || null;
+        const relayCredential = context.credential || (resolveRuntimeAppToken(runtimeConfig)
+          ? { type: 'agent_token', token: resolveRuntimeAppToken(runtimeConfig) }
+          : null);
+
+        if (!relayAgentId) {
+          logger.warn?.(`[claworld:${runtimeAccountId}] missing relay runtime context; deferring connect`);
+          return { startedDeferred: true, reason: 'missing_runtime_context', runtimeConfig };
+        }
+
+        const pluginRuntime = runtimeResolution.runtime;
+        const runtimeSource = runtimeResolution.runtimeSource;
+
+        logger.info?.(`[claworld:${runtimeAccountId}] runtime surface resolved`, {
+          runtimeSource,
+        });
+
+        try {
+          const persisted = await persistRuntimeAppToken({
+            runtime: pluginRuntime,
+            accountId: runtimeConfig.accountId,
+            appToken: resolveRuntimeAppToken(runtimeConfig),
+            relayAgentId: runtimeConfig.relay?.agentId || null,
+          });
+          if (!persisted.skipped || persisted.backup?.skipped === false) {
+            logger.info?.(`[claworld:${runtimeAccountId}] persisted runtime binding state`, {
+              accountId: runtimeConfig.accountId,
+              configSkipped: persisted.skipped === true,
+              backupSkipped: persisted.backup?.skipped === true,
+            });
+          }
+        } catch (error) {
+          logger.warn?.(`[claworld:${runtimeAccountId}] failed to persist runtime appToken`, {
+            error: error?.message || String(error),
+          });
+        }
+
+        accountRuntimeContexts.set(accountKey, {
+          runtime: pluginRuntime,
+          cfg: context.cfg || null,
+          runtimeConfig,
+          deferredFailure: null,
+          deferredErrorMessage: null,
+        });
+
+        const relayClient = relayClientFactory({ logger, inbound, outbound, protocol });
+        relayClients.set(accountKey, relayClient);
+
+        relayClient.on?.('close', (info = {}) => {
+          logger.warn?.(`[claworld:${runtimeAccountId}] relay websocket closed`, info);
+        });
+        relayClient.on?.('runtime_event', (event) => {
+          logger.debug?.(`[claworld:${runtimeAccountId}] inbound relay event`, {
+            eventType: event?.eventType || null,
+            target: event?.route?.target || null,
+            deliveryId: event?.delivery?.deliveryId || null,
+            sessionKey: event?.delivery?.sessionKey || null,
+          });
+
+          if (event?.eventType === 'delivery') {
+            const runtimeContext = accountRuntimeContexts.get(accountKey) || {};
+            maybeBridgeRuntimeDelivery({
+              relayClient,
+              runtimeConfig,
+              runtimeAccountId,
+              event,
+              logger,
+              runtime: runtimeContext.runtime,
+              cfg: runtimeContext.cfg,
+              inbound,
+            }).catch((error) => {
+              logger.error?.(`[claworld:${runtimeAccountId}] delivery bridge exception`, {
+                error: error?.message || String(error),
+              });
+            });
+          }
+        });
+
+        if (context.autoConnect === false) {
+          logger.info?.(`[claworld:${runtimeAccountId}] lifecycle started in deferred mode (autoConnect=false)`);
+          return { startedDeferred: true, runtimeConfig, relayClient };
+        }
+
+        logger.info?.(`[claworld:${runtimeAccountId}] connecting relay websocket ...`);
+        await relayClient.connect({
+          config: runtimeConfig,
+          agentId: relayAgentId,
+          credential: relayCredential,
+          clientVersion: context.clientVersion,
+          sessionTarget: context.sessionTarget || runtimeConfig.routing?.sessionTarget,
+          fallbackTarget: context.fallbackTarget || runtimeConfig.routing?.fallbackTarget,
+        });
+        logger.info?.(`[claworld:${runtimeAccountId}] auth ok`);
+        return relayClient;
+      },
+      disconnect: async ({ reason }) => {
+        const relayClient = relayClients.get(accountKey);
+        if (relayClient) {
+          await relayClient.close(reason);
+          relayClients.delete(accountKey);
+        }
+        accountRuntimeContexts.delete(accountKey);
+        accountBindingStates.delete(accountKey);
+      },
+    });
+
+    lifecycles.set(accountKey, lifecycle);
+    return lifecycle;
+  }
+
+  async function runAccountLifecycle(context = {}) {
+    const accountKey = String(context.accountId || context.account?.accountId || 'default');
+    const lifecycle = getAccountLifecycle(accountKey);
+    const started = await lifecycle.start(context);
+    const runtimeAccountId = String(
+      context.accountId
+      || context.account?.accountId
+      || started?.connection?.runtimeConfig?.accountId
+      || accountKey
+    );
+
+    if (!context.abortSignal) {
+      logger.warn?.(`[claworld:${runtimeAccountId}] no abortSignal; startAccount will behave as a short-lived start call`);
+      return started;
+    }
+
+    if (context.abortSignal.aborted) {
+      logger.info?.(`[claworld:${runtimeAccountId}] abort already signaled before runtime entered steady state`);
+      await lifecycle.stop('abort_before_run');
+      return started;
+    }
+
+    const startedDeferred = Boolean(started?.connection?.startedDeferred);
+    logger.info?.(
+      `[claworld:${runtimeAccountId}] account runtime started; waiting for ${
+        startedDeferred ? 'abort while setup is deferred' : 'abort'
+      }`,
+    );
+    const stopReason = startedDeferred
+      ? await waitForAbort(context.abortSignal)
+      : await Promise.race([
+        waitForAbort(context.abortSignal),
+        waitForRelayClientClose(started?.connection),
+      ]);
+
+    if (stopReason?.reason === 'abort_signal') {
+      logger.info?.(`[claworld:${runtimeAccountId}] abort signal received, stopping`);
+      await lifecycle.stop('abort_signal');
+      return started;
+    }
+
+    logger.warn?.(`[claworld:${runtimeAccountId}] account runtime ended before abort`, stopReason);
+    await lifecycle.stop(stopReason?.reason || 'runtime_stopped');
+    return started;
+  }
+
+  function createStatusSnapshot() {
+    const configuredAccounts = new Set([
+      ...listClaworldAccountIds({ channels: { claworld: { accounts: {} } } }),
+      ...Array.from(accountRuntimeContexts.keys()),
+      ...Array.from(relayClients.keys()),
+      ...Array.from(lifecycles.keys()),
+    ]);
+
+    const accountSnapshots = Object.fromEntries(
+      Array.from(configuredAccounts).map((accountId) => {
+        const lifecycle = lifecycles.get(accountId)?.snapshot?.() || null;
+        const relayClient = relayClients.get(accountId)?.snapshot?.() || null;
+        const runtimeContext = accountRuntimeContexts.get(accountId) || null;
+        const deferredFailure = runtimeContext?.deferredFailure || null;
+        const connected = Boolean(relayClient && relayClient.connectionState === 'authenticated');
+        const lastFailure = lifecycle?.lastStartFailure || deferredFailure || null;
+        const lastError = runtimeContext?.deferredErrorMessage || lifecycle?.lastStartError || deferredFailure?.message || null;
+        const setupBlocked = isNonRecoverableBootstrapHoldError(lastFailure);
+        const degraded = Boolean(lastError) || Boolean(relayClient && relayClient.connectionState === 'error');
+        return [accountId, {
+          configured: !setupBlocked,
+          enabled: true,
+          connected,
+          degraded,
+          hasRuntime: Boolean(runtimeContext?.runtime),
+          hasCfg: Boolean(runtimeContext?.cfg),
+          lifecycle,
+          relayClient,
+          lastError,
+          lastFailure,
+        }];
+      }),
+    );
+
+    return {
+      ok: true,
+      pluginId: 'claworld',
+      version: CLAWORLD_PLUGIN_CURRENT_VERSION,
+      defaultAccountId: null,
+      accounts: accountSnapshots,
+      relayClients: Object.fromEntries(
+        Array.from(relayClients.entries()).map(([accountId, client]) => [accountId, client?.snapshot?.() || null]),
+      ),
+      lifecycles: Object.fromEntries(
+        Array.from(lifecycles.entries()).map(([accountId, lifecycle]) => [accountId, lifecycle.snapshot()]),
+      ),
+    };
+  }
+
+  async function getRuntimePublicIdentity(context = {}) {
+    const resolvedContext = resolveConfiguredRuntimeContext(context);
+    return fetchPublicIdentity({
+      runtimeConfig: resolvedContext.runtimeConfig,
+      agentId: resolvedContext.agentId || null,
+      generateShareCard: context.generateShareCard === true,
+      expiresInSeconds: context.expiresInSeconds ?? null,
+      fetchImpl,
+    });
+  }
+
+async function updateRuntimePublicIdentity(context = {}) {
+    const resolvedContext = resolveConfiguredRuntimeContext(context);
+    const updateResult = await updatePublicIdentity({
+      runtimeConfig: resolvedContext.runtimeConfig,
+      agentId: resolvedContext.agentId || null,
+      displayName: context.displayName || null,
+      generateShareCard: context.generateShareCard !== false,
+      expiresInSeconds: context.expiresInSeconds ?? null,
+      fetchImpl,
+    });
+
+    const runtimeActivation = updateResult?.runtimeActivation && typeof updateResult.runtimeActivation === 'object'
+      ? updateResult.runtimeActivation
+      : null;
+    const nextRuntimeConfig = updateResult?.runtimeConfig && typeof updateResult.runtimeConfig === 'object'
+      ? updateResult.runtimeConfig
+      : resolvedContext.runtimeConfig;
+    const nextAgentId = normalizeClaworldText(
+      runtimeActivation?.agentId,
+      normalizeClaworldText(
+        updateResult?.agentId,
+        null,
+      ),
+    ) || normalizeClaworldText(
+      normalizeClaworldText(resolvedContext.agentId, normalizeClaworldText(nextRuntimeConfig?.relay?.agentId, null)),
+      null,
+    );
+    const boundRuntimeConfig = nextAgentId
+      ? applyRuntimeIdentity(nextRuntimeConfig, { agentId: nextAgentId })
+      : nextRuntimeConfig;
+
+    const previousAgentId = normalizeClaworldText(
+      resolvedContext.runtimeConfig?.relay?.agentId,
+      normalizeClaworldText(resolvedContext.agentId, null),
+    );
+    const shouldPersistRuntimeBinding = Boolean(
+      resolveRuntimeAppToken(nextRuntimeConfig)
+      && nextAgentId
+      && (runtimeActivation || previousAgentId !== nextAgentId),
+    );
+
+    if (shouldPersistRuntimeBinding) {
+      const runtimeResolution = resolvePluginRuntimeCandidate(context.runtime || null);
+      try {
+        await persistRuntimeAppToken({
+          runtime: runtimeResolution.runtime,
+          accountId: resolvedContext.accountId || boundRuntimeConfig.accountId || null,
+          appToken: resolveRuntimeAppToken(boundRuntimeConfig),
+          relayAgentId: nextAgentId,
+        });
+      } catch (error) {
+        logger.warn?.('[claworld:profile] failed to persist activated runtime binding', {
+          accountId: resolvedContext.accountId || boundRuntimeConfig.accountId || null,
+          error: error?.message || String(error),
+        });
+      }
+
+      rememberAccountBinding({
+        runtimeConfig: boundRuntimeConfig,
+        accountId: resolvedContext.accountId || boundRuntimeConfig.accountId || null,
+        bindingSource: runtimeActivation ? 'activated_app_token' : 'configured_app_token',
+      });
+
+      const accountKey = resolveAccountBindingKey(boundRuntimeConfig, resolvedContext.accountId || null);
+      const currentRuntimeContext = accountRuntimeContexts.get(accountKey) || null;
+      if (currentRuntimeContext) {
+        accountRuntimeContexts.set(accountKey, {
+          ...currentRuntimeContext,
+          runtimeConfig: boundRuntimeConfig,
+          deferredFailure: null,
+          deferredErrorMessage: null,
+        });
+      }
+    }
+
+    const payload = updateResult && typeof updateResult === 'object' && !Array.isArray(updateResult)
+      ? { ...updateResult }
+      : {};
+  delete payload.runtimeConfig;
+  return payload;
+}
+
+async function updateRuntimeChatRequestApprovalPolicy(context = {}) {
+  const resolvedContext = await resolveBoundRuntimeContext(context);
+  return updateChatRequestApprovalPolicy({
+    runtimeConfig: resolvedContext.runtimeConfig,
+    agentId: resolvedContext.agentId || null,
+    chatRequestApprovalPolicy: context.chatRequestApprovalPolicy || null,
+    fetchImpl,
+  });
+}
+
+async function updateRuntimeProfile(context = {}) {
+  const resolvedContext = await resolveBoundRuntimeContext(context);
+  return updateGlobalProfile({
+    runtimeConfig: resolvedContext.runtimeConfig,
+    agentId: resolvedContext.agentId || null,
+    profile: Object.prototype.hasOwnProperty.call(context, 'profile')
+      ? (context.profile == null ? '' : String(context.profile))
+      : '',
+    fetchImpl,
+  });
+}
+
+async function generateRuntimeProfileCard(context = {}) {
+  const resolvedContext = await resolveBoundRuntimeContext(context);
+  const result = await fetchPublicIdentity({
+    runtimeConfig: resolvedContext.runtimeConfig,
+    agentId: context.agentId || resolvedContext.agentId || null,
+    generateShareCard: true,
+    expiresInSeconds: context.expiresInSeconds ?? null,
+    fetchImpl,
+  });
+  return result?.shareCard || {};
+}
+
+  return {
+    id: 'claworld',
+    meta: {
+      id: 'claworld',
+      label: 'Claworld',
+      selectionLabel: 'Claworld Relay Channel',
+      detailLabel: 'Claworld A2A Relay Channel',
+      docsPath: '/channels/claworld',
+      docsLabel: 'claworld',
+      blurb: 'Claworld relay channel backed by the Claworld backend.',
+      version: CLAWORLD_PLUGIN_CURRENT_VERSION,
+      forceAccountBinding: true,
+    },
+    onboarding: claworldOnboardingAdapter,
+    capabilities: {
+      chatTypes: ['direct'],
+      polls: false,
+      threads: false,
+      reactions: false,
+      media: false,
+      edit: false,
+      reply: true,
+    },
+    agentPrompt: {
+      messageToolHints: () => [
+        '- Claworld message targets are canonical `agentId` values such as `agt_xxx`.',
+        '- Omit `target` to keep replying inside the current A2A session when the runtime already inferred the peer.',
+        '- For new chat requests, use the target `displayName` plus public `agentCode`; the backend resolves by `agentCode` and returns a warning if the displayName is stale.',
+      ],
+    },
+    reload: { configPrefixes: ['channels.claworld'] },
+    configSchema: {
+      schema: claworldChannelConfigJsonSchema,
+    },
+    config: {
+      schema: claworldChannelConfigSchema,
+      validate: validateClaworldChannelConfig,
+      listAccountIds: (cfg) => listClaworldAccountIds(cfg),
+      defaultAccountId: (cfg) => defaultClaworldAccountId(cfg),
+      inspectAccount: (cfg, accountId) =>
+        projectClaworldStatusAccount(inspectClaworldChannelAccount(cfg, accountId)),
+      resolveAccount: (cfg, accountId) => resolveClaworldChannelAccount(cfg, accountId),
+      resolveRuntimeConfig: (cfg, accountId) => resolveClaworldRuntimeConfig(cfg, accountId),
+      isConfigured: (account, cfg) => {
+        if (account?.configured != null) return Boolean(account.configured);
+        return inspectClaworldChannelAccount(account || cfg || {}).configured;
+      },
+      describeAccount: (account, cfg) => {
+        if (account?.configured != null) return account;
+        return inspectClaworldChannelAccount(account || cfg || {});
+      },
+    },
+    setup: claworldSetupAdapter,
+    messaging: {
+      normalizeTarget: (raw) => normalizeClaworldTarget(raw) ?? undefined,
+      targetResolver: {
+        looksLikeId: (raw, normalized) => {
+          const value = String(normalized || raw || '').trim();
+          if (!value) return false;
+          return /^agt_[a-z0-9_-]+$/i.test(value);
+        },
+        hint: '<agentId>',
+      },
+    },
+    directory: {
+      self: async ({ cfg, accountId } = {}) => {
+        const account = inspectClaworldChannelAccount(cfg || {}, accountId || null);
+        const agentId = normalizeClaworldText(account?.relay?.agentId, null);
+        if (!account?.configured || !agentId) return null;
+        return {
+          id: agentId,
+          name: account.accountId,
+          handle: account.accountId,
+        };
+      },
+      listPeers: async ({ cfg, accountId } = {}) => buildClaworldDirectoryEntries(cfg || {}, accountId || null),
+      listGroups: async () => [],
+    },
+    status: {
+      getSnapshot: () => createStatusSnapshot(),
+    },
+    gateway: {
+      startAccount: async (context = {}) => {
+        context.log?.info?.(`starting claworld[${context.accountId || context.account?.accountId || 'default'}]`);
+        return runAccountLifecycle({
+          ...context,
+          config: context.cfg || context.config || context.account || {},
+        });
+      },
+      stopAccount: async (context = {}) => {
+        const accountKey = String(context.accountId || context.account?.accountId || 'default');
+        const lifecycle = getAccountLifecycle(accountKey);
+        return lifecycle.stop('stop_account');
+      },
+      start: (context = {}) => runAccountLifecycle(context),
+      stop: async (reasonOrContext = 'manual_stop') => {
+        if (typeof reasonOrContext === 'object' && reasonOrContext !== null) {
+          const accountKey = String(reasonOrContext.accountId || reasonOrContext.account?.accountId || 'default');
+          return getAccountLifecycle(accountKey).stop(reasonOrContext.reason || 'manual_stop');
+        }
+        const entries = Array.from(lifecycles.entries());
+        await Promise.all(entries.map(([, lifecycle]) => lifecycle.stop(reasonOrContext)));
+        return { started: false, stopped: true, reason: reasonOrContext };
+      },
+      reconnect: async (context = {}) => {
+        const accountKey = String(context.accountId || context.account?.accountId || 'default');
+        return getAccountLifecycle(accountKey).reconnect(context);
+      },
+      snapshot: () => ({
+        lifecycles: Object.fromEntries(Array.from(lifecycles.entries()).map(([accountId, lifecycle]) => [accountId, lifecycle.snapshot()])),
+        relayClients: Object.fromEntries(Array.from(relayClients.entries()).map(([accountId, client]) => [accountId, client?.snapshot?.() || null])),
+      }),
+    },
+    inbound: {
+      routeRelayEvent: (event = {}, options = {}) => {
+        return inbound.routeInboundEvent({
+          eventType: event.eventType || event.type || 'delivery',
+          deliveryId: event.deliveryId || event.event_id || event.eventId || null,
+          sessionKey: event.sessionKey || null,
+          payload: event.payload || {},
+          metadata: event.metadata || {},
+        }, options);
+      },
+    },
+    outbound: {
+      deliveryMode: 'direct',
+      createReplyEnvelope: (params = {}) => outbound.createReplyEnvelope(params),
+      sendText: async (ctx = {}) => {
+        if (typeof fetchImpl !== 'function') throw new Error('fetch is unavailable for claworld outbound');
+        const resolvedContext = await resolveBoundRuntimeContext(ctx);
+        return deliverRelayMessage({
+          runtimeConfig: resolvedContext.runtimeConfig,
+          to: ctx.to,
+          text: ctx.text,
+          fetchImpl,
+          logger,
+          outboundContext: ctx,
+        });
+      },
+    },
+    helpers: {
+      resolveToolRuntimeContext: resolveBoundRuntimeContext,
+      pairing: {
+        resolveAgentIdentity: async (context = {}) => resolveRelayAgentSummary({
+          runtimeConfig: context.runtimeConfig || resolveClaworldRuntimeConfig(context.cfg || {}, context.accountId || null),
+          fetchImpl,
+          logger,
+          agentId: context.agentId || context.targetAgentId || null,
+        }),
+      },
+      social: {
+        requestChat: async (context = {}) => {
+          const resolvedContext = await resolveBoundRuntimeContext(context);
+          const requestContext = resolvedContext.requesterSessionKey
+            ? {
+                followUp: {
+                  sessionKey: resolvedContext.requesterSessionKey,
+                },
+              }
+            : null;
+          return createChatRequest({
+            runtimeConfig: resolvedContext.runtimeConfig,
+            fromAgentId: resolvedContext.agentId || null,
+            displayName: context.displayName || null,
+            agentCode: context.agentCode || null,
+            openingMessage: context.openingMessage || context.message || context.text || null,
+            worldId: context.worldId || null,
+            requestContext,
+            fetchImpl,
+          });
+        },
+        listChatInbox: async (context = {}) => {
+          const resolvedContext = await resolveBoundRuntimeContext(context);
+          return listChatInbox({
+            runtimeConfig: resolvedContext.runtimeConfig,
+            agentId: resolvedContext.agentId || null,
+            localAgentId: resolveContextBoundLocalAgentId(resolvedContext),
+            filters: context.filters || null,
+            direction: context.direction || null,
+            fetchImpl,
+          });
+        },
+        acceptChatRequest: async (context = {}) => {
+          const resolvedContext = await resolveBoundRuntimeContext(context);
+          return acceptChatRequest({
+            runtimeConfig: resolvedContext.runtimeConfig,
+            actorAgentId: resolvedContext.agentId || null,
+            chatRequestId: context.chatRequestId || null,
+            localAgentId: resolveContextBoundLocalAgentId(resolvedContext),
+            fetchImpl,
+          });
+        },
+        rejectChatRequest: async (context = {}) => {
+          const resolvedContext = await resolveBoundRuntimeContext(context);
+          return rejectChatRequest({
+            runtimeConfig: resolvedContext.runtimeConfig,
+            actorAgentId: resolvedContext.agentId || null,
+            chatRequestId: context.chatRequestId || null,
+            fetchImpl,
+          });
+        },
+      },
+      profile: {
+        getPublicIdentity: getRuntimePublicIdentity,
+        updatePublicIdentity: updateRuntimePublicIdentity,
+        updateProfile: updateRuntimeProfile,
+        updateChatRequestApprovalPolicy: updateRuntimeChatRequestApprovalPolicy,
+        generateShareCard: generateRuntimeProfileCard,
+      },
+      postSetup: {
+        fetchWorldDirectory: async (context = {}) => {
+          const resolvedContext = await resolveBoundRuntimeContext(context);
+          return fetchPostSetupWorldDirectory({
+            cfg: resolvedContext.cfg || {},
+            accountId: resolvedContext.accountId || null,
+            runtimeConfig: resolvedContext.runtimeConfig || null,
+            limit: context.limit ?? null,
+            sort: context.sort || null,
+            page: context.page ?? null,
+            fetchImpl,
+            logger,
+          });
+        },
+        fetchWorldDetail: async (context = {}) => {
+          const resolvedContext = await resolveBoundRuntimeContext(context);
+          return fetchWorldDetail({
+            cfg: resolvedContext.cfg || {},
+            accountId: resolvedContext.accountId || null,
+            runtimeConfig: resolvedContext.runtimeConfig || null,
+            worldId: context.worldId || null,
+            fetchImpl,
+            logger,
+          });
+        },
+        searchWorlds: async (context = {}) => {
+          const resolvedContext = await resolveBoundRuntimeContext(context);
+          return searchWorlds({
+            cfg: resolvedContext.cfg || {},
+            accountId: resolvedContext.accountId || null,
+            runtimeConfig: resolvedContext.runtimeConfig || null,
+            query: context.query ?? context.queryText ?? null,
+            limit: context.limit ?? null,
+            sort: context.sort || null,
+            page: context.page ?? null,
+            fetchImpl,
+            logger,
+          });
+        },
+        joinWorld: async (context = {}) => {
+          const resolvedContext = await resolveBoundRuntimeContext(context);
+          return joinWorld({
+            cfg: resolvedContext.cfg || {},
+            accountId: resolvedContext.accountId || null,
+            runtimeConfig: resolvedContext.runtimeConfig || null,
+            worldId: context.worldId || null,
+            agentId: resolvedContext.agentId || null,
+            participantContextText: context.participantContextText || null,
+            fetchImpl,
+            logger,
+          });
+        },
+        searchWorldMembers: async (context = {}) => {
+          const resolvedContext = await resolveBoundRuntimeContext(context);
+          return searchWorldMembers({
+            cfg: resolvedContext.cfg || {},
+            accountId: resolvedContext.accountId || null,
+            runtimeConfig: resolvedContext.runtimeConfig || null,
+            worldId: context.worldId || null,
+            agentId: resolvedContext.agentId || null,
+            query: context.query ?? context.queryText ?? null,
+            sort: context.sort || null,
+            limit: context.limit ?? null,
+            fetchImpl,
+            logger,
+          });
+        },
+        fetchWorldCandidateFeed: async (context = {}) => {
+          const resolvedContext = await resolveBoundRuntimeContext(context);
+          return fetchWorldCandidateFeed({
+            cfg: resolvedContext.cfg || {},
+            accountId: resolvedContext.accountId || null,
+            runtimeConfig: resolvedContext.runtimeConfig || null,
+            worldId: context.worldId || null,
+            agentId: resolvedContext.agentId || null,
+            limit: context.limit ?? context.candidateLimit ?? null,
+            fetchImpl,
+            logger,
+          });
+        },
+        resolveWorldSelection: (context = {}) => resolveWorldSelection(
+          context.worldDirectory || {},
+          context.selection ?? context.userChoice ?? null,
+        ),
+        buildCandidateDeliverySummary,
+        resolveWorldSelectionFlow: async (context = {}) => {
+          const resolvedContext = await resolveBoundRuntimeContext(context);
+          return resolveWorldSelectionFlow({
+            cfg: resolvedContext.cfg || {},
+            accountId: resolvedContext.accountId || null,
+            runtimeConfig: resolvedContext.runtimeConfig || null,
+            worldDirectory: context.worldDirectory || null,
+            selection: context.selection ?? context.userChoice ?? null,
+            profile: context.profile || {},
+            fetchImpl,
+            logger,
+          });
+        },
+      },
+      moderation: {
+        createWorld: async (context = {}) => {
+          const resolvedContext = await resolveBoundRuntimeContext(context);
+          return createModeratedWorld({
+            cfg: resolvedContext.cfg || {},
+            accountId: resolvedContext.accountId || null,
+            runtimeConfig: resolvedContext.runtimeConfig || null,
+            agentId: resolvedContext.agentId || null,
+            displayName: context.displayName || null,
+            worldContextText: context.worldContextText || null,
+            participantContextText: context.participantContextText || null,
+            enabled: typeof context.enabled === 'boolean' ? context.enabled : true,
+            fetchImpl,
+            logger,
+          });
+        },
+        listOwnedWorlds: async (context = {}) => {
+          const resolvedContext = await resolveBoundRuntimeContext(context);
+          return fetchOwnedWorlds({
+            cfg: resolvedContext.cfg || {},
+            accountId: resolvedContext.accountId || null,
+            runtimeConfig: resolvedContext.runtimeConfig || null,
+            agentId: resolvedContext.agentId || null,
+            includeDisabled: context.includeDisabled !== false,
+            fetchImpl,
+            logger,
+          });
+        },
+        broadcastWorld: async (context = {}) => {
+          const resolvedContext = await resolveBoundRuntimeContext(context);
+          return broadcastModeratedWorld({
+            cfg: resolvedContext.cfg || {},
+            accountId: resolvedContext.accountId || null,
+            runtimeConfig: resolvedContext.runtimeConfig || null,
+            agentId: resolvedContext.agentId || null,
+            worldId: context.worldId || null,
+            announcementText: context.announcementText || null,
+            audience: context.audience || null,
+            excludeSelf: Object.prototype.hasOwnProperty.call(context, 'excludeSelf') ? context.excludeSelf : null,
+            fetchImpl,
+            logger,
+          });
+        },
+        manageWorld: async (context = {}) => {
+          const resolvedContext = await resolveBoundRuntimeContext(context);
+          return manageModeratedWorld({
+            cfg: resolvedContext.cfg || {},
+            accountId: resolvedContext.accountId || null,
+            runtimeConfig: resolvedContext.runtimeConfig || null,
+            agentId: resolvedContext.agentId || null,
+            worldId: context.worldId || null,
+            mode: context.mode || 'get',
+            changes: context.changes || null,
+            enabled: Object.prototype.hasOwnProperty.call(context, 'enabled') ? context.enabled : null,
+            status: context.status || null,
+            fetchImpl,
+            logger,
+          });
+        },
+      },
+      membership: {
+        listWorldMemberships: async (context = {}) => {
+          const resolvedContext = await resolveBoundRuntimeContext(context);
+          return fetchWorldMemberships({
+            cfg: resolvedContext.cfg || {},
+            accountId: resolvedContext.accountId || null,
+            runtimeConfig: resolvedContext.runtimeConfig || null,
+            agentId: resolvedContext.agentId || null,
+            status: context.status || null,
+            includeInactive: context.includeInactive === true,
+            includeDisabled: context.includeDisabled !== false,
+            fetchImpl,
+            logger,
+          });
+        },
+        getWorldMembership: async (context = {}) => {
+          const resolvedContext = await resolveBoundRuntimeContext(context);
+          return fetchWorldMembership({
+            cfg: resolvedContext.cfg || {},
+            accountId: resolvedContext.accountId || null,
+            runtimeConfig: resolvedContext.runtimeConfig || null,
+            agentId: resolvedContext.agentId || null,
+            worldId: context.worldId || null,
+            includeDisabled: context.includeDisabled !== false,
+            fetchImpl,
+            logger,
+          });
+        },
+        updateWorldMembershipProfile: async (context = {}) => {
+          const resolvedContext = await resolveBoundRuntimeContext(context);
+          return updateWorldMembershipProfile({
+            cfg: resolvedContext.cfg || {},
+            accountId: resolvedContext.accountId || null,
+            runtimeConfig: resolvedContext.runtimeConfig || null,
+            agentId: resolvedContext.agentId || null,
+            worldId: context.worldId || null,
+            participantContextText: context.participantContextText || null,
+            fetchImpl,
+            logger,
+          });
+        },
+        leaveWorldMembership: async (context = {}) => {
+          const resolvedContext = await resolveBoundRuntimeContext(context);
+          return leaveWorldMembership({
+            cfg: resolvedContext.cfg || {},
+            accountId: resolvedContext.accountId || null,
+            runtimeConfig: resolvedContext.runtimeConfig || null,
+            agentId: resolvedContext.agentId || null,
+            worldId: context.worldId || null,
+            fetchImpl,
+            logger,
+          });
+        },
+      },
+    },
+    runtime: {
+      protocol,
+      inbound,
+      outbound,
+      results,
+      demo,
+      productShell: {
+        profile: {
+          getPublicIdentity: getRuntimePublicIdentity,
+          updatePublicIdentity: updateRuntimePublicIdentity,
+          updateProfile: updateRuntimeProfile,
+          updateChatRequestApprovalPolicy: updateRuntimeChatRequestApprovalPolicy,
+          generateShareCard: generateRuntimeProfileCard,
+        },
+        fetchWorldDirectory: async (context = {}) => {
+          const resolvedContext = await resolveBoundRuntimeContext(context);
+          return fetchPostSetupWorldDirectory({
+            cfg: resolvedContext.cfg || {},
+            accountId: resolvedContext.accountId || null,
+            runtimeConfig: resolvedContext.runtimeConfig || null,
+            limit: context.limit ?? null,
+            sort: context.sort || null,
+            page: context.page ?? null,
+            fetchImpl,
+            logger,
+          });
+        },
+        buildWorldSelectionPrompt,
+        fetchWorldDetail: async (context = {}) => {
+          const resolvedContext = await resolveBoundRuntimeContext(context);
+          return fetchWorldDetail({
+            cfg: resolvedContext.cfg || {},
+            accountId: resolvedContext.accountId || null,
+            runtimeConfig: resolvedContext.runtimeConfig || null,
+            worldId: context.worldId || null,
+            fetchImpl,
+            logger,
+          });
+        },
+        searchWorlds: async (context = {}) => {
+          const resolvedContext = await resolveBoundRuntimeContext(context);
+          return searchWorlds({
+            cfg: resolvedContext.cfg || {},
+            accountId: resolvedContext.accountId || null,
+            runtimeConfig: resolvedContext.runtimeConfig || null,
+            query: context.query ?? context.queryText ?? null,
+            limit: context.limit ?? null,
+            sort: context.sort || null,
+            page: context.page ?? null,
+            fetchImpl,
+            logger,
+          });
+        },
+        joinWorld: async (context = {}) => {
+          const resolvedContext = await resolveBoundRuntimeContext(context);
+          return joinWorld({
+            cfg: resolvedContext.cfg || {},
+            accountId: resolvedContext.accountId || null,
+            runtimeConfig: resolvedContext.runtimeConfig || null,
+            worldId: context.worldId || null,
+            agentId: resolvedContext.agentId || null,
+            participantContextText: context.participantContextText || null,
+            fetchImpl,
+            logger,
+          });
+        },
+        searchWorldMembers: async (context = {}) => {
+          const resolvedContext = await resolveBoundRuntimeContext(context);
+          return searchWorldMembers({
+            cfg: resolvedContext.cfg || {},
+            accountId: resolvedContext.accountId || null,
+            runtimeConfig: resolvedContext.runtimeConfig || null,
+            worldId: context.worldId || null,
+            agentId: resolvedContext.agentId || null,
+            query: context.query ?? context.queryText ?? null,
+            sort: context.sort || null,
+            limit: context.limit ?? null,
+            fetchImpl,
+            logger,
+          });
+        },
+        fetchWorldCandidateFeed: async (context = {}) => {
+          const resolvedContext = await resolveBoundRuntimeContext(context);
+          return fetchWorldCandidateFeed({
+            cfg: resolvedContext.cfg || {},
+            accountId: resolvedContext.accountId || null,
+            runtimeConfig: resolvedContext.runtimeConfig || null,
+            worldId: context.worldId || null,
+            agentId: resolvedContext.agentId || null,
+            limit: context.limit ?? context.candidateLimit ?? null,
+            fetchImpl,
+            logger,
+          });
+        },
+        resolveWorldSelection,
+        buildCandidateDeliverySummary,
+        resolveWorldSelectionFlow: async (context = {}) => {
+          const resolvedContext = await resolveBoundRuntimeContext(context);
+          return resolveWorldSelectionFlow({
+            cfg: resolvedContext.cfg || {},
+            accountId: resolvedContext.accountId || null,
+            runtimeConfig: resolvedContext.runtimeConfig || null,
+            worldDirectory: context.worldDirectory || null,
+            selection: context.selection ?? context.userChoice ?? null,
+            profile: context.profile || {},
+            fetchImpl,
+            logger,
+          });
+        },
+        feedback: {
+          submitFeedback: async (context = {}) => {
+            const resolvedContext = await resolveBoundRuntimeContext(context);
+            return submitFeedbackReport({
+              cfg: resolvedContext.cfg || {},
+              accountId: resolvedContext.accountId || null,
+              runtimeConfig: resolvedContext.runtimeConfig || null,
+              agentId: resolvedContext.agentId || null,
+              category: context.category || null,
+              title: context.title || null,
+              goal: context.goal || null,
+              actualBehavior: context.actualBehavior || null,
+              expectedBehavior: context.expectedBehavior || null,
+              impact: context.impact || null,
+              details: context.details || null,
+              reproductionSteps: context.reproductionSteps || [],
+              context: context.context || {},
+              fetchImpl,
+              logger,
+              toolCallId: context.toolCallId || null,
+              pluginVersion: context.pluginVersion || null,
+              toolContractVersion: context.toolContractVersion || null,
+            });
+          },
+        },
+        moderation: {
+          createWorld: async (context = {}) => {
+            const resolvedContext = await resolveBoundRuntimeContext(context);
+            return createModeratedWorld({
+              cfg: resolvedContext.cfg || {},
+              accountId: resolvedContext.accountId || null,
+              runtimeConfig: resolvedContext.runtimeConfig || null,
+              agentId: resolvedContext.agentId || null,
+              displayName: context.displayName || null,
+              worldContextText: context.worldContextText || null,
+              participantContextText: context.participantContextText || null,
+              enabled: typeof context.enabled === 'boolean' ? context.enabled : true,
+              fetchImpl,
+              logger,
+            });
+          },
+          listOwnedWorlds: async (context = {}) => {
+            const resolvedContext = await resolveBoundRuntimeContext(context);
+            return fetchOwnedWorlds({
+              cfg: resolvedContext.cfg || {},
+              accountId: resolvedContext.accountId || null,
+              runtimeConfig: resolvedContext.runtimeConfig || null,
+              agentId: resolvedContext.agentId || null,
+              includeDisabled: context.includeDisabled !== false,
+              fetchImpl,
+              logger,
+            });
+          },
+          broadcastWorld: async (context = {}) => {
+            const resolvedContext = await resolveBoundRuntimeContext(context);
+            return broadcastModeratedWorld({
+              cfg: resolvedContext.cfg || {},
+              accountId: resolvedContext.accountId || null,
+              runtimeConfig: resolvedContext.runtimeConfig || null,
+              agentId: resolvedContext.agentId || null,
+              worldId: context.worldId || null,
+              announcementText: context.announcementText || null,
+              audience: context.audience || null,
+              excludeSelf: Object.prototype.hasOwnProperty.call(context, 'excludeSelf') ? context.excludeSelf : null,
+              fetchImpl,
+              logger,
+            });
+          },
+          manageWorld: async (context = {}) => {
+            const resolvedContext = await resolveBoundRuntimeContext(context);
+            return manageModeratedWorld({
+              cfg: resolvedContext.cfg || {},
+              accountId: resolvedContext.accountId || null,
+              runtimeConfig: resolvedContext.runtimeConfig || null,
+              agentId: resolvedContext.agentId || null,
+              worldId: context.worldId || null,
+              mode: context.mode || 'get',
+              changes: context.changes || null,
+              enabled: Object.prototype.hasOwnProperty.call(context, 'enabled') ? context.enabled : null,
+              status: context.status || null,
+              fetchImpl,
+              logger,
+            });
+          },
+        },
+        membership: {
+          listWorldMemberships: async (context = {}) => {
+            const resolvedContext = await resolveBoundRuntimeContext(context);
+            return fetchWorldMemberships({
+              cfg: resolvedContext.cfg || {},
+              accountId: resolvedContext.accountId || null,
+              runtimeConfig: resolvedContext.runtimeConfig || null,
+              agentId: resolvedContext.agentId || null,
+              status: context.status || null,
+              includeInactive: context.includeInactive === true,
+              includeDisabled: context.includeDisabled !== false,
+              fetchImpl,
+              logger,
+            });
+          },
+          getWorldMembership: async (context = {}) => {
+            const resolvedContext = await resolveBoundRuntimeContext(context);
+            return fetchWorldMembership({
+              cfg: resolvedContext.cfg || {},
+              accountId: resolvedContext.accountId || null,
+              runtimeConfig: resolvedContext.runtimeConfig || null,
+              agentId: resolvedContext.agentId || null,
+              worldId: context.worldId || null,
+              includeDisabled: context.includeDisabled !== false,
+              fetchImpl,
+              logger,
+            });
+          },
+          updateWorldMembershipProfile: async (context = {}) => {
+            const resolvedContext = await resolveBoundRuntimeContext(context);
+            return updateWorldMembershipProfile({
+              cfg: resolvedContext.cfg || {},
+              accountId: resolvedContext.accountId || null,
+              runtimeConfig: resolvedContext.runtimeConfig || null,
+              agentId: resolvedContext.agentId || null,
+              worldId: context.worldId || null,
+              participantContextText: context.participantContextText || null,
+              fetchImpl,
+              logger,
+            });
+          },
+          leaveWorldMembership: async (context = {}) => {
+            const resolvedContext = await resolveBoundRuntimeContext(context);
+            return leaveWorldMembership({
+              cfg: resolvedContext.cfg || {},
+              accountId: resolvedContext.accountId || null,
+              runtimeConfig: resolvedContext.runtimeConfig || null,
+              agentId: resolvedContext.agentId || null,
+              worldId: context.worldId || null,
+              fetchImpl,
+              logger,
+            });
+          },
+        },
+      },
+      createRelayClient: (options = {}) => relayClientFactory({ logger, inbound, outbound, protocol, ...options }),
+    },
+    internals: {
+      protocol,
+      inbound,
+      outbound,
+      results,
+      demo,
+      lifecycles,
+      getRelayClient: (accountId = 'default') => relayClients.get(accountId) || null,
+    },
+    async start(context = {}) {
+      return runAccountLifecycle(context);
+    },
+    async stop(reason) {
+      return this.gateway.stop(reason);
+    },
+    async reconnect(context = {}) {
+      return this.gateway.reconnect(context);
+    },
+    describe() {
+      return {
+        id: this.id,
+        meta: this.meta,
+        capabilities: this.capabilities,
+        configSchema: this.configSchema,
+        runtimePath: inbound.runtimePath,
+        lifecycle: this.gateway.snapshot(),
+        relayClient: relayClients.get('default')?.snapshot?.() || null,
+        status: createStatusSnapshot(),
+        readyFor: [
+          'plugin manifest validation',
+          'config inspection',
+          'native channel setup/onboarding',
+          'relay websocket adapter tests',
+          'manual relay-agent binding',
+          'minimal outbound conversation send',
+        ],
+        notImplemented: [
+          '真实 OpenClaw sdk import/types 对齐',
+          'ack/retry persistence',
+          'console + demo wiring',
+        ],
+      };
+    },
+  };
+}
+
+export const claworldChannelPluginScaffold = createClaworldChannelPlugin;
+export { normalizeRelayHttpBaseUrl };