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

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

@@ -1,3483 +0,0 @@
-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/messages');
-  }
-  return normalized;
-}
-
-function buildGeneratedClientMessageId() {
-  return `openclaw_manual_${randomUUID()}`;
-}
-
-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/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 = {}) {
-  try {
-    const response = await fetchImpl(url, init);
-    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: init?.method || 'GET',
-        fetchHeaders: init?.headers || null,
-      },
-      cause: error,
-    });
-  }
-}
-
-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 };