@xfxstudio/claworld 2026.4.22-testing.5 → 2026.4.22-testing.7

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

@@ -52,6 +52,7 @@ import {
   fetchWorldCandidateFeed,
   fetchWorldDetail,
   joinWorld,
+  search,
   searchWorldMembers,
   searchWorlds,
   resolveWorldSelection,
@@ -637,6 +638,33 @@ async function createChatRequest({
     });
   }
   const baseUrl = normalizeRelayHttpBaseUrl(runtimeConfig.serverUrl);
+  const normalizedOpeningMessage = normalizeClaworldText(openingMessage, null);
+  if (!normalizedOpeningMessage) {
+    const message = 'openingMessage is required for chat request kickoff';
+    throw createRuntimeBoundaryError({
+      code: 'opening_message_required',
+      category: 'input',
+      status: 400,
+      message,
+      publicMessage: message,
+      recoverable: true,
+      context: {
+        accountId: runtimeConfig.accountId || null,
+        httpStatus: 400,
+        backendCode: 'opening_message_required',
+        backendMessage: message,
+        fieldErrors: [
+          {
+            fieldId: 'openingMessage',
+            message,
+          },
+        ],
+        fromAgentId,
+        displayName: normalizedDisplayName,
+        agentCode: normalizedAgentCode,
+      },
+    });
+  }
   const result = await fetchJson(fetchImpl, `${baseUrl}/v1/chat-requests`, {
     method: 'POST',
     headers: {
@@ -648,7 +676,7 @@ async function createChatRequest({
       fromAgentId,
       displayName: normalizedDisplayName,
       agentCode: normalizedAgentCode,
-      openingMessage: normalizeClaworldText(openingMessage, null),
+      openingMessage: normalizedOpeningMessage,
       ...(normalizeClaworldText(worldId, null) ? { worldId: normalizeClaworldText(worldId, null) } : {}),
       ...(requestContext && typeof requestContext === 'object' && !Array.isArray(requestContext)
         ? { requestContext }
@@ -978,7 +1006,7 @@ async function fetchPublicIdentity({
       recommendedDisplayName,
       nextAction: 'set_public_identity',
       requiredAction: 'set_public_identity',
-      nextTool: 'claworld_account',
+      nextTool: 'claworld_manage_account',
       missingFields: [
         {
           fieldId: 'displayName',
@@ -1328,6 +1356,301 @@ async function fetchPostSetupWorldDirectory({ cfg, accountId, runtimeConfig, lim
   });
 }
 
+async function executeRuntimeAccountAction({
+  runtimeConfig,
+  agentId = null,
+  action = 'view_account',
+  displayName = null,
+  profile = undefined,
+  humanProfile = undefined,
+  agentProfile = undefined,
+  discoverable = undefined,
+  contactable = undefined,
+  chatRequestApprovalPolicy = null,
+  proactivitySettings = undefined,
+  communicationPreference = undefined,
+  generateShareCard = false,
+  expiresInSeconds = null,
+  fetchImpl,
+}) {
+  if (!resolveRuntimeAppToken(runtimeConfig)) {
+    throw createRuntimeBoundaryError({
+      code: 'claworld_account_unactivated',
+      category: 'conflict',
+      status: 409,
+      message: 'claworld account must be activated before managing account settings',
+      publicMessage: 'activate the Claworld account before changing account settings',
+      recoverable: true,
+    });
+  }
+
+  const baseUrl = normalizeRelayHttpBaseUrl(runtimeConfig.serverUrl);
+  const result = await fetchJson(fetchImpl, `${baseUrl}/v1/account`, {
+    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,
+      ...(displayName != null ? { displayName } : {}),
+      ...(profile !== undefined ? { profile } : {}),
+      ...(humanProfile !== undefined ? { humanProfile } : {}),
+      ...(agentProfile !== undefined ? { agentProfile } : {}),
+      ...(discoverable !== undefined ? { discoverable } : {}),
+      ...(contactable !== undefined ? { contactable } : {}),
+      ...(chatRequestApprovalPolicy ? { chatRequestApprovalPolicy } : {}),
+      ...(proactivitySettings !== undefined ? { proactivitySettings } : {}),
+      ...(communicationPreference !== undefined ? { communicationPreference } : {}),
+      ...(generateShareCard === true ? { generateShareCard: true } : {}),
+      ...(normalizeClaworldInteger(expiresInSeconds, null) > 0
+        ? { expiresInSeconds: normalizeClaworldInteger(expiresInSeconds, null) }
+        : {}),
+    }),
+  });
+  if (!result.ok) {
+    createRelayRouteError({
+      result,
+      runtimeConfig,
+      code: 'account_action_failed',
+      publicMessage: 'failed to manage Claworld account',
+      context: {
+        accountId: runtimeConfig.accountId || null,
+        agentId: normalizeClaworldText(agentId, null),
+        action,
+      },
+    });
+  }
+  return result.body || {};
+}
+
+async function fetchRuntimeSubscriptions({
+  runtimeConfig,
+  agentId = null,
+  targetType = null,
+  status = 'active',
+  fetchImpl,
+}) {
+  const baseUrl = normalizeRelayHttpBaseUrl(runtimeConfig.serverUrl);
+  const requestUrl = new URL(`${baseUrl}/v1/subscriptions`);
+  if (agentId) requestUrl.searchParams.set('agentId', agentId);
+  if (targetType) requestUrl.searchParams.set('targetType', targetType);
+  if (status) requestUrl.searchParams.set('status', status);
+  const result = await fetchJson(fetchImpl, requestUrl.toString(), {
+    headers: {
+      accept: 'application/json',
+      ...(runtimeConfig.apiKey ? { 'x-api-key': runtimeConfig.apiKey } : {}),
+      ...buildRuntimeAuthHeaders(runtimeConfig),
+    },
+  });
+  if (!result.ok) {
+    createRelayRouteError({
+      result,
+      runtimeConfig,
+      code: 'subscription_list_failed',
+      publicMessage: 'failed to list Claworld subscriptions',
+      context: { agentId: normalizeClaworldText(agentId, null), targetType },
+    });
+  }
+  return result.body || { items: [] };
+}
+
+async function createRuntimeSubscription({
+  runtimeConfig,
+  agentId = null,
+  targetType,
+  targetId,
+  broadcastEnabled = true,
+  fetchImpl,
+}) {
+  const normalizedTargetType = normalizeClaworldText(targetType, null);
+  const normalizedTargetId = normalizeClaworldText(targetId, null);
+  if (!normalizedTargetType || !normalizedTargetId) {
+    throw createRuntimeBoundaryError({
+      code: 'tool_input_invalid',
+      category: 'input',
+      status: 400,
+      message: 'subscription targetType and targetId are required',
+      publicMessage: 'subscription targetType and targetId are required',
+      recoverable: true,
+      context: { field: normalizedTargetType ? 'targetId' : 'targetType' },
+    });
+  }
+  const baseUrl = normalizeRelayHttpBaseUrl(runtimeConfig.serverUrl);
+  const result = await fetchJson(fetchImpl, `${baseUrl}/v1/subscriptions`, {
+    method: 'POST',
+    headers: {
+      'content-type': 'application/json',
+      ...(runtimeConfig.apiKey ? { 'x-api-key': runtimeConfig.apiKey } : {}),
+      ...buildRuntimeAuthHeaders(runtimeConfig),
+    },
+    body: JSON.stringify({
+      ...(agentId ? { agentId } : {}),
+      targetType: normalizedTargetType,
+      targetId: normalizedTargetId,
+      broadcastEnabled: broadcastEnabled !== false,
+    }),
+  });
+  if (!result.ok) {
+    createRelayRouteError({
+      result,
+      runtimeConfig,
+      code: 'subscription_create_failed',
+      publicMessage: 'failed to create Claworld subscription',
+      context: { agentId: normalizeClaworldText(agentId, null), targetType: normalizedTargetType, targetId: normalizedTargetId },
+    });
+  }
+  return result.body || {};
+}
+
+async function deleteRuntimeSubscription({
+  runtimeConfig,
+  agentId = null,
+  subscriptionId = null,
+  targetType = null,
+  targetId = null,
+  fetchImpl,
+}) {
+  let normalizedSubscriptionId = normalizeClaworldText(subscriptionId, null);
+  const normalizedTargetType = normalizeClaworldText(targetType, null);
+  const normalizedTargetId = normalizeClaworldText(targetId, null);
+  if (!normalizedSubscriptionId && normalizedTargetType && normalizedTargetId) {
+    const listPayload = await fetchRuntimeSubscriptions({
+      runtimeConfig,
+      agentId,
+      targetType: normalizedTargetType,
+      status: 'active',
+      fetchImpl,
+    });
+    normalizedSubscriptionId = (Array.isArray(listPayload.items) ? listPayload.items : [])
+      .find((subscription) => normalizeClaworldText(subscription.targetId, null) === normalizedTargetId)
+      ?.subscriptionId || null;
+  }
+  if (!normalizedSubscriptionId) {
+    throw createRuntimeBoundaryError({
+      code: 'tool_input_invalid',
+      category: 'input',
+      status: 400,
+      message: 'subscriptionId or targetType/targetId is required to delete a subscription',
+      publicMessage: 'subscriptionId or targetType/targetId is required to delete a subscription',
+      recoverable: true,
+      context: { field: 'subscriptionId' },
+    });
+  }
+  const baseUrl = normalizeRelayHttpBaseUrl(runtimeConfig.serverUrl);
+  const result = await fetchJson(fetchImpl, `${baseUrl}/v1/subscriptions/${encodeURIComponent(normalizedSubscriptionId)}`, {
+    method: 'DELETE',
+    headers: {
+      'content-type': 'application/json',
+      ...(runtimeConfig.apiKey ? { 'x-api-key': runtimeConfig.apiKey } : {}),
+      ...buildRuntimeAuthHeaders(runtimeConfig),
+    },
+    body: JSON.stringify({
+      ...(agentId ? { agentId } : {}),
+    }),
+  });
+  if (!result.ok) {
+    createRelayRouteError({
+      result,
+      runtimeConfig,
+      code: 'subscription_delete_failed',
+      publicMessage: 'failed to delete Claworld subscription',
+      context: { agentId: normalizeClaworldText(agentId, null), subscriptionId: normalizedSubscriptionId },
+    });
+  }
+  return result.body || {};
+}
+
+async function fetchRuntimeWorldActivity({
+  runtimeConfig,
+  agentId = null,
+  worldId = null,
+  limit = null,
+  fetchImpl,
+}) {
+  const normalizedWorldId = normalizeClaworldText(worldId, null);
+  if (!normalizedWorldId) {
+    throw createRuntimeBoundaryError({
+      code: 'tool_input_invalid',
+      category: 'input',
+      status: 400,
+      message: 'worldId is required',
+      publicMessage: 'worldId is required',
+      recoverable: true,
+      context: { field: 'worldId' },
+    });
+  }
+  const baseUrl = normalizeRelayHttpBaseUrl(runtimeConfig.serverUrl);
+  const requestUrl = new URL(`${baseUrl}/v1/worlds/${encodeURIComponent(normalizedWorldId)}/activity`);
+  if (agentId) requestUrl.searchParams.set('agentId', agentId);
+  if (limit != null) requestUrl.searchParams.set('limit', String(limit));
+  const result = await fetchJson(fetchImpl, requestUrl.toString(), {
+    headers: {
+      accept: 'application/json',
+      ...(runtimeConfig.apiKey ? { 'x-api-key': runtimeConfig.apiKey } : {}),
+      ...buildRuntimeAuthHeaders(runtimeConfig),
+    },
+  });
+  if (!result.ok) {
+    createRelayRouteError({
+      result,
+      runtimeConfig,
+      code: 'world_activity_fetch_failed',
+      publicMessage: 'failed to list world activity',
+      context: { agentId: normalizeClaworldText(agentId, null), worldId: normalizedWorldId },
+    });
+  }
+  return result.body || {};
+}
+
+async function fetchRuntimeWorldMembers({
+  runtimeConfig,
+  agentId = null,
+  worldId = null,
+  status = null,
+  limit = null,
+  fetchImpl,
+}) {
+  const normalizedWorldId = normalizeClaworldText(worldId, null);
+  if (!normalizedWorldId) {
+    throw createRuntimeBoundaryError({
+      code: 'tool_input_invalid',
+      category: 'input',
+      status: 400,
+      message: 'worldId is required',
+      publicMessage: 'worldId is required',
+      recoverable: true,
+      context: { field: 'worldId' },
+    });
+  }
+  const baseUrl = normalizeRelayHttpBaseUrl(runtimeConfig.serverUrl);
+  const requestUrl = new URL(`${baseUrl}/v1/worlds/${encodeURIComponent(normalizedWorldId)}/memberships`);
+  if (agentId) requestUrl.searchParams.set('agentId', agentId);
+  if (status) requestUrl.searchParams.set('status', status);
+  const normalizedLimit = normalizeClaworldInteger(limit, null);
+  if (normalizedLimit > 0) requestUrl.searchParams.set('limit', String(normalizedLimit));
+  const result = await fetchJson(fetchImpl, requestUrl.toString(), {
+    headers: {
+      accept: 'application/json',
+      ...(runtimeConfig.apiKey ? { 'x-api-key': runtimeConfig.apiKey } : {}),
+      ...buildRuntimeAuthHeaders(runtimeConfig),
+    },
+  });
+  if (!result.ok) {
+    createRelayRouteError({
+      result,
+      runtimeConfig,
+      code: 'world_members_fetch_failed',
+      publicMessage: 'failed to list world members',
+      context: { agentId: normalizeClaworldText(agentId, null), worldId: normalizedWorldId },
+    });
+  }
+  return result.body || {};
+}
+
 async function ensureRelayBinding({ runtimeConfig, fetchImpl, logger }) {
   const normalizedRuntimeConfig = applyRuntimeIdentity(runtimeConfig);
   const registration = normalizeRuntimeRegistration(normalizedRuntimeConfig);
@@ -2983,6 +3306,26 @@ async function generateRuntimeProfileCard(context = {}) {
       },
       profile: {
         getPublicIdentity: getRuntimePublicIdentity,
+        executeAccountAction: async (context = {}) => {
+          const resolvedContext = await resolveBoundRuntimeContext(context);
+          return executeRuntimeAccountAction({
+            runtimeConfig: resolvedContext.runtimeConfig,
+            agentId: resolvedContext.agentId || null,
+            action: context.action || 'view_account',
+            displayName: context.displayName || null,
+            profile: Object.prototype.hasOwnProperty.call(context, 'profile') ? context.profile : undefined,
+            humanProfile: Object.prototype.hasOwnProperty.call(context, 'humanProfile') ? context.humanProfile : undefined,
+            agentProfile: Object.prototype.hasOwnProperty.call(context, 'agentProfile') ? context.agentProfile : undefined,
+            discoverable: Object.prototype.hasOwnProperty.call(context, 'discoverable') ? context.discoverable : undefined,
+            contactable: Object.prototype.hasOwnProperty.call(context, 'contactable') ? context.contactable : undefined,
+            chatRequestApprovalPolicy: context.chatRequestApprovalPolicy || null,
+            proactivitySettings: Object.prototype.hasOwnProperty.call(context, 'proactivitySettings') ? context.proactivitySettings : undefined,
+            communicationPreference: Object.prototype.hasOwnProperty.call(context, 'communicationPreference') ? context.communicationPreference : undefined,
+            generateShareCard: context.generateShareCard === true,
+            expiresInSeconds: context.expiresInSeconds ?? null,
+            fetchImpl,
+          });
+        },
         updatePublicIdentity: updateRuntimePublicIdentity,
         updateProfile: updateRuntimeProfile,
         updateChatRequestApprovalPolicy: updateRuntimeChatRequestApprovalPolicy,
@@ -3087,6 +3430,52 @@ async function generateRuntimeProfileCard(context = {}) {
           });
         },
       },
+      subscriptions: {
+        listSubscriptions: async (context = {}) => {
+          const resolvedContext = await resolveBoundRuntimeContext(context);
+          return fetchRuntimeSubscriptions({
+            runtimeConfig: resolvedContext.runtimeConfig,
+            agentId: resolvedContext.agentId || null,
+            targetType: context.targetType || null,
+            status: context.status || 'active',
+            fetchImpl,
+          });
+        },
+        createSubscription: async (context = {}) => {
+          const resolvedContext = await resolveBoundRuntimeContext(context);
+          return createRuntimeSubscription({
+            runtimeConfig: resolvedContext.runtimeConfig,
+            agentId: resolvedContext.agentId || null,
+            targetType: context.targetType || null,
+            targetId: context.targetId || null,
+            broadcastEnabled: context.broadcastEnabled !== false,
+            fetchImpl,
+          });
+        },
+        deleteSubscription: async (context = {}) => {
+          const resolvedContext = await resolveBoundRuntimeContext(context);
+          return deleteRuntimeSubscription({
+            runtimeConfig: resolvedContext.runtimeConfig,
+            agentId: resolvedContext.agentId || null,
+            subscriptionId: context.subscriptionId || null,
+            targetType: context.targetType || null,
+            targetId: context.targetId || null,
+            fetchImpl,
+          });
+        },
+      },
+      activity: {
+        listWorldActivity: async (context = {}) => {
+          const resolvedContext = await resolveBoundRuntimeContext(context);
+          return fetchRuntimeWorldActivity({
+            runtimeConfig: resolvedContext.runtimeConfig,
+            agentId: resolvedContext.agentId || null,
+            worldId: context.worldId || null,
+            limit: context.limit ?? null,
+            fetchImpl,
+          });
+        },
+      },
       moderation: {
         createWorld: async (context = {}) => {
           const resolvedContext = await resolveBoundRuntimeContext(context);
@@ -3148,6 +3537,17 @@ async function generateRuntimeProfileCard(context = {}) {
         },
       },
       membership: {
+        listWorldMembers: async (context = {}) => {
+          const resolvedContext = await resolveBoundRuntimeContext(context);
+          return fetchRuntimeWorldMembers({
+            runtimeConfig: resolvedContext.runtimeConfig,
+            agentId: resolvedContext.agentId || null,
+            worldId: context.worldId || null,
+            status: context.status || null,
+            limit: context.limit ?? null,
+            fetchImpl,
+          });
+        },
         listWorldMemberships: async (context = {}) => {
           const resolvedContext = await resolveBoundRuntimeContext(context);
           return fetchWorldMemberships({
@@ -3211,6 +3611,26 @@ async function generateRuntimeProfileCard(context = {}) {
       productShell: {
         profile: {
           getPublicIdentity: getRuntimePublicIdentity,
+          executeAccountAction: async (context = {}) => {
+            const resolvedContext = await resolveBoundRuntimeContext(context);
+            return executeRuntimeAccountAction({
+              runtimeConfig: resolvedContext.runtimeConfig,
+              agentId: resolvedContext.agentId || null,
+              action: context.action || 'view_account',
+              displayName: context.displayName || null,
+              profile: Object.prototype.hasOwnProperty.call(context, 'profile') ? context.profile : undefined,
+              humanProfile: Object.prototype.hasOwnProperty.call(context, 'humanProfile') ? context.humanProfile : undefined,
+              agentProfile: Object.prototype.hasOwnProperty.call(context, 'agentProfile') ? context.agentProfile : undefined,
+              discoverable: Object.prototype.hasOwnProperty.call(context, 'discoverable') ? context.discoverable : undefined,
+              contactable: Object.prototype.hasOwnProperty.call(context, 'contactable') ? context.contactable : undefined,
+              chatRequestApprovalPolicy: context.chatRequestApprovalPolicy || null,
+              proactivitySettings: Object.prototype.hasOwnProperty.call(context, 'proactivitySettings') ? context.proactivitySettings : undefined,
+              communicationPreference: Object.prototype.hasOwnProperty.call(context, 'communicationPreference') ? context.communicationPreference : undefined,
+              generateShareCard: context.generateShareCard === true,
+              expiresInSeconds: context.expiresInSeconds ?? null,
+              fetchImpl,
+            });
+          },
           updatePublicIdentity: updateRuntimePublicIdentity,
           updateProfile: updateRuntimeProfile,
           updateChatRequestApprovalPolicy: updateRuntimeChatRequestApprovalPolicy,
@@ -3255,6 +3675,23 @@ async function generateRuntimeProfileCard(context = {}) {
             logger,
           });
         },
+        search: async (context = {}) => {
+          const resolvedContext = await resolveBoundRuntimeContext(context);
+          return search({
+            cfg: resolvedContext.cfg || {},
+            accountId: resolvedContext.accountId || null,
+            runtimeConfig: resolvedContext.runtimeConfig || null,
+            scope: context.scope || 'mixed',
+            worldId: context.worldId || null,
+            agentId: resolvedContext.agentId || 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({
@@ -3311,6 +3748,52 @@ async function generateRuntimeProfileCard(context = {}) {
             logger,
           });
         },
+        subscriptions: {
+          listSubscriptions: async (context = {}) => {
+            const resolvedContext = await resolveBoundRuntimeContext(context);
+            return fetchRuntimeSubscriptions({
+              runtimeConfig: resolvedContext.runtimeConfig,
+              agentId: resolvedContext.agentId || null,
+              targetType: context.targetType || null,
+              status: context.status || 'active',
+              fetchImpl,
+            });
+          },
+          createSubscription: async (context = {}) => {
+            const resolvedContext = await resolveBoundRuntimeContext(context);
+            return createRuntimeSubscription({
+              runtimeConfig: resolvedContext.runtimeConfig,
+              agentId: resolvedContext.agentId || null,
+              targetType: context.targetType || null,
+              targetId: context.targetId || null,
+              broadcastEnabled: context.broadcastEnabled !== false,
+              fetchImpl,
+            });
+          },
+          deleteSubscription: async (context = {}) => {
+            const resolvedContext = await resolveBoundRuntimeContext(context);
+            return deleteRuntimeSubscription({
+              runtimeConfig: resolvedContext.runtimeConfig,
+              agentId: resolvedContext.agentId || null,
+              subscriptionId: context.subscriptionId || null,
+              targetType: context.targetType || null,
+              targetId: context.targetId || null,
+              fetchImpl,
+            });
+          },
+        },
+        activity: {
+          listWorldActivity: async (context = {}) => {
+            const resolvedContext = await resolveBoundRuntimeContext(context);
+            return fetchRuntimeWorldActivity({
+              runtimeConfig: resolvedContext.runtimeConfig,
+              agentId: resolvedContext.agentId || null,
+              worldId: context.worldId || null,
+              limit: context.limit ?? null,
+              fetchImpl,
+            });
+          },
+        },
         feedback: {
           submitFeedback: async (context = {}) => {
             const resolvedContext = await resolveBoundRuntimeContext(context);
@@ -3398,6 +3881,17 @@ async function generateRuntimeProfileCard(context = {}) {
           },
         },
         membership: {
+          listWorldMembers: async (context = {}) => {
+            const resolvedContext = await resolveBoundRuntimeContext(context);
+            return fetchRuntimeWorldMembers({
+              runtimeConfig: resolvedContext.runtimeConfig,
+              agentId: resolvedContext.agentId || null,
+              worldId: context.worldId || null,
+              status: context.status || null,
+              limit: context.limit ?? null,
+              fetchImpl,
+            });
+          },
           listWorldMemberships: async (context = {}) => {
             const resolvedContext = await resolveBoundRuntimeContext(context);
             return fetchWorldMemberships({

package/src/openclaw/plugin/config-schema.js

@@ -40,12 +40,12 @@ export const MANUAL_RELAY_BINDING_SCHEMA = {
     agentId: {
       type: 'string',
       minLength: 1,
-      description: 'Legacy relay agent id hint. Canonical flow resolves the binding from appToken at runtime.',
+      description: 'Optional relay agent id hint. The current flow resolves the binding from appToken at runtime.',
     },
     credentialToken: {
       type: 'string',
       minLength: 1,
-      description: 'Legacy alias for appToken.',
+      description: 'Optional credential token for this account. appToken is the current field.',
     },
     defaultTargetAgentId: {
       type: 'string',
@@ -85,7 +85,7 @@ const SINGLE_ACCOUNT_PROPERTIES = {
   toolProfile: {
     type: 'string',
     enum: ['minimal', 'default', 'world', 'full'],
-    description: 'Legacy ignored field retained for backward-compatible config parsing.',
+    description: 'Optional ignored profile selector. Current tool exposure is backend-defined.',
   },
   heartbeatSeconds: {
     type: 'integer',

package/src/openclaw/plugin/onboarding.js

@@ -247,7 +247,7 @@ async function applyManagedOnboardingConfig({
     `Remote backend: ${managedOptions.serverUrl}`,
     managedOptions.appToken
       ? 'Activation state: ready via configured appToken'
-      : 'Activation state: pending until claworld_account(action=update_identity) runs',
+      : 'Activation state: pending until claworld_manage_account(action=update_display_name) runs',
     'This flow refreshes plugin-side config and binds claworld onto the selected local agent. It does not run installer commands or start a backend service.',
   ];
   await prompter.note(

package/src/openclaw/plugin/register-tooling.js

@@ -69,7 +69,7 @@ async function buildPendingPublicIdentityError({
         backendMessage: fallbackMessage,
         requiredAction: 'set_public_identity',
         nextAction: 'set_public_identity',
-        nextTool: 'claworld_account',
+        nextTool: 'claworld_manage_account',
       },
     });
   }
@@ -101,7 +101,7 @@ async function buildPendingPublicIdentityError({
       backendMessage: publicMessage,
       requiredAction: normalizeText(identityPayload?.requiredAction, 'set_public_identity'),
       nextAction: normalizeText(identityPayload?.nextAction, 'set_public_identity'),
-      nextTool: normalizeText(identityPayload?.nextTool, 'claworld_account'),
+      nextTool: normalizeText(identityPayload?.nextTool, 'claworld_manage_account'),
       missingFields: Array.isArray(identityPayload?.missingFields) ? identityPayload.missingFields : [],
       publicIdentity: normalizeObject(identityPayload?.publicIdentity, null),
     },