@xfxstudio/claworld 2026.4.28-testing → 2026.4.28-testing.1

package/src/openclaw/plugin/register.js

@@ -173,13 +173,16 @@ const TERMINAL_WORLD_ACTIONS = Object.freeze([
   'list_world_activity',
   'list_broadcast_history',
   'manage_members',
+  'list_invites',
+  'invite_member',
+  'revoke_invite',
 ]);
 
 const TERMINAL_CONVERSATION_ACTIONS = Object.freeze([
   'request',
   'accept',
   'reject',
-  'end',
+  'close',
   'get_state',
   'list_related',
 ]);
@@ -235,6 +238,7 @@ function normalizeTerminalWorldAction(params = {}) {
     requireManageWorldField('action', `action must be one of ${TERMINAL_WORLD_ACTIONS.join(', ')}`);
   }
   if (!normalizeText(params.worldId, null)) return 'list_owned_worlds';
+  if (normalizeText(params.targetAgentId, null) || normalizeText(params.identity, null)) return 'invite_member';
   if (normalizeText(params.announcementText, null)) return 'publish_broadcast';
   if (normalizeText(params.participantContextText, null)) return 'update_world_profile';
   if (
@@ -511,10 +515,42 @@ function createTerminalToolAdapters(api, plugin, internalTools) {
             minLength: 1,
             examples: ['网球 搭子 周末约球'],
           }),
+          keywords: arrayParam({
+            description: 'Structured keywords for agent-authored search.',
+            items: stringParam({ minLength: 1 }),
+          }),
+          topics: arrayParam({
+            description: 'Structured topics for agent-authored search.',
+            items: stringParam({ minLength: 1 }),
+          }),
+          location: stringParam({
+            description: 'Optional structured location signal.',
+            minLength: 1,
+            examples: ['上海'],
+          }),
+          timeWindow: stringParam({
+            description: 'Optional structured time-window signal.',
+            minLength: 1,
+            examples: ['周末'],
+          }),
+          intent: stringParam({
+            description: 'Agent task intent for ranking and result action selection.',
+            enumValues: ['join_world', 'find_member', 'find_public_person'],
+            examples: ['join_world'],
+          }),
+          desiredInteraction: stringParam({
+            description: 'Optional structured interaction preference.',
+            minLength: 1,
+            examples: ['线下约球'],
+          }),
+          constraints: arrayParam({
+            description: 'Structured constraints that should influence search matching.',
+            items: stringParam({ minLength: 1 }),
+          }),
           sort: stringParam({
             description: 'Sort mode for the selected scope.',
-            enumValues: ['match', 'hot', 'latest', 'likes'],
-            examples: ['match'],
+            enumValues: ['relevance', 'hot', 'latest', 'likes', 'activity'],
+            examples: ['relevance'],
           }),
           limit: integerParam({
             description: 'Maximum result count.',
@@ -529,8 +565,8 @@ function createTerminalToolAdapters(api, plugin, internalTools) {
           }),
         },
         examples: [
-          { accountId: 'claworld', scope: 'worlds', query: '网球', sort: 'match', limit: 5 },
-          { accountId: 'claworld', scope: 'world_members', worldId: 'dating-demo-world', query: '上海 周末', limit: 5 },
+          { accountId: 'claworld', scope: 'worlds', keywords: ['网球', '上海', '周末'], intent: 'join_world', sort: 'relevance', limit: 5 },
+          { accountId: 'claworld', scope: 'world_members', worldId: 'dating-demo-world', keywords: ['上海', '周末'], intent: 'find_member', limit: 5 },
           { accountId: 'claworld', scope: 'people', query: 'Moza', limit: 5 },
           { accountId: 'claworld', scope: 'mixed', query: '网球 Moza', limit: 5 },
         ],
@@ -549,6 +585,13 @@ function createTerminalToolAdapters(api, plugin, internalTools) {
           scope,
           worldId: params.worldId || null,
           query: params.query || null,
+          keywords: params.keywords || [],
+          topics: params.topics || [],
+          location: params.location || null,
+          timeWindow: params.timeWindow || null,
+          intent: params.intent || null,
+          desiredInteraction: params.desiredInteraction || null,
+          constraints: params.constraints || [],
           sort: params.sort || null,
           limit: params.limit ?? null,
           page: params.page ?? null,
@@ -559,7 +602,7 @@ function createTerminalToolAdapters(api, plugin, internalTools) {
     {
       name: publicProfileTool,
       label: 'Claworld Get Public Profile',
-      description: 'Read the current account public profile/readiness projection. Target public-profile lookup is exposed as a terminal tool name and remains backend-fact based.',
+      description: 'Read the current account public profile or perform exact displayName#code public-profile lookup.',
       metadata: buildToolMetadata({
         category: 'public_profile',
         usageNotes: [
@@ -571,13 +614,27 @@ function createTerminalToolAdapters(api, plugin, internalTools) {
         description: 'Public profile lookup payload.',
         properties: {
           accountId: accountIdProperty,
+          action: stringParam({
+            description: 'Public-profile action.',
+            enumValues: ['get_profile', 'lookup_profile'],
+            examples: ['lookup_profile'],
+          }),
+          identity: stringParam({
+            description: 'Exact public identity in displayName#code form for action=lookup_profile.',
+            minLength: 1,
+            examples: ['Runtime Peer#ZX82QP'],
+          }),
+          agentId: stringParam({
+            description: 'Optional target agent id for action=get_profile; defaults to the current account binding.',
+            minLength: 1,
+          }),
           agentCode: stringParam({
-            description: 'Optional public code for a future target lookup route.',
+            description: 'Public code paired with displayName for action=lookup_profile.',
             minLength: 1,
             examples: ['ZX82QP'],
           }),
           displayName: stringParam({
-            description: 'Optional display name paired with agentCode for a future target lookup route.',
+            description: 'Display name paired with agentCode for action=lookup_profile.',
             minLength: 1,
             examples: ['Runtime Peer'],
           }),
@@ -592,11 +649,31 @@ function createTerminalToolAdapters(api, plugin, internalTools) {
         },
       }),
       async execute(toolCallId, params = {}) {
-        const result = await requireTerminalTool(internalTools, 'claworld_account').execute(toolCallId, {
-          ...params,
-          action: 'view',
-        });
-        return rewriteToolResultName(result, publicProfileTool);
+        const action = normalizeText(
+          params.action,
+          params.identity || params.agentCode || params.displayName ? 'lookup_profile' : 'get_profile',
+        );
+        if (!['get_profile', 'lookup_profile'].includes(action)) {
+          requireManageWorldField('action', 'action must be one of get_profile or lookup_profile');
+        }
+        const context = await resolveToolContext(api, plugin, params);
+        const lookupIdentity = normalizeText(
+          params.identity,
+          params.displayName && params.agentCode ? `${params.displayName}#${params.agentCode}` : null,
+        );
+        if (action === 'lookup_profile' && !lookupIdentity) {
+          requireManageWorldField('identity', 'identity or displayName+agentCode is required for action=lookup_profile');
+        }
+        const payload = action === 'lookup_profile'
+          ? await plugin.runtime.productShell.publicProfiles.lookupPublicProfile({
+            ...context,
+            identity: lookupIdentity,
+          })
+          : await plugin.runtime.productShell.publicProfiles.getPublicProfile({
+            ...context,
+            agentId: normalizeText(params.agentId, context.agentId),
+          });
+        return buildTerminalActionResult({ tool: publicProfileTool, action, payload });
       },
     },
     {
@@ -610,7 +687,6 @@ function createTerminalToolAdapters(api, plugin, internalTools) {
           'action=create_world creates an owner-managed world.',
           'Owner governance and member self-service actions use terminal action names such as update_world, publish_broadcast, and update_world_profile.',
           'Subscription, activity, and member-list actions are backed by the product-shell terminal routes.',
-          'Retired feed-style recommendations are not exposed as terminal public actions.',
         ],
       }),
       parameters: objectParam({
@@ -632,9 +708,16 @@ function createTerminalToolAdapters(api, plugin, internalTools) {
           excludeSelf: booleanParam({ description: 'Whether broadcast excludes the sender.' }),
           includeDisabled: booleanParam({ description: 'Whether list actions include disabled rows.' }),
           enabled: booleanParam({ description: 'Whether create/resume should enable the world.' }),
+          visibility: stringParam({ description: 'World visibility for discovery/access policy.', enumValues: ['public', 'private'] }),
+          identityMode: stringParam({ description: 'World identity mode.', enumValues: ['imaginary', 'realistic'] }),
+          joinPolicy: stringParam({ description: 'Owner-defined join policy.', minLength: 1 }),
+          approvalPolicy: stringParam({ description: 'Owner-defined approval policy.', minLength: 1 }),
           broadcastEnabled: booleanParam({ description: 'Whether a world subscription should receive broadcasts.' }),
           broadcast: objectParam({ description: 'Optional broadcast config for update_world or set_world_broadcast_preference.', additionalProperties: true }),
           subscriptionId: stringParam({ description: 'Existing subscription id for unsubscribe_world.', minLength: 1 }),
+          targetAgentId: stringParam({ description: 'Target agent id for private-world invitation actions.', minLength: 1 }),
+          identity: stringParam({ description: 'Target public identity displayName#code for private-world invitation actions.', minLength: 1 }),
+          inviteMessage: stringParam({ description: 'Optional private-world invitation note.', minLength: 1 }),
           limit: integerParam({ description: 'Maximum rows for activity/member listing actions.', minimum: 1, maximum: 100 }),
           status: stringParam({ description: 'Optional membership/subscription status filter.', minLength: 1 }),
         },
@@ -720,12 +803,64 @@ function createTerminalToolAdapters(api, plugin, internalTools) {
           });
           return buildTerminalActionResult({ tool: manageWorldsTool, action, payload });
         }
+        if (action === 'list_invites') {
+          const worldId = normalizeText(params.worldId, null);
+          if (!worldId) requireManageWorldField('worldId');
+          const context = await resolveToolContext(api, plugin, params, {
+            requiredPublicIdentityCapability: 'list world invites',
+          });
+          const payload = await plugin.runtime.productShell.moderation.listInvites({
+            ...context,
+            worldId,
+            status: params.status || 'invited',
+          });
+          return buildTerminalActionResult({ tool: manageWorldsTool, action, payload });
+        }
+        if (action === 'invite_member') {
+          const worldId = normalizeText(params.worldId, null);
+          if (!worldId) requireManageWorldField('worldId');
+          const targetAgentId = normalizeText(params.targetAgentId, null);
+          const identity = normalizeText(params.identity, null);
+          if (!targetAgentId && !identity) {
+            requireManageWorldField('targetAgentId', 'targetAgentId or identity is required for action=invite_member');
+          }
+          const context = await resolveToolContext(api, plugin, params, {
+            requiredPublicIdentityCapability: 'invite world member',
+          });
+          const payload = await plugin.runtime.productShell.moderation.inviteMember({
+            ...context,
+            worldId,
+            targetAgentId,
+            identity,
+            inviteMessage: normalizeText(params.inviteMessage, null),
+          });
+          return buildTerminalActionResult({ tool: manageWorldsTool, action, payload });
+        }
+        if (action === 'revoke_invite') {
+          const worldId = normalizeText(params.worldId, null);
+          if (!worldId) requireManageWorldField('worldId');
+          const targetAgentId = normalizeText(params.targetAgentId, null);
+          if (!targetAgentId) requireManageWorldField('targetAgentId');
+          const context = await resolveToolContext(api, plugin, params, {
+            requiredPublicIdentityCapability: 'revoke world invite',
+          });
+          const payload = await plugin.runtime.productShell.moderation.revokeInvite({
+            ...context,
+            worldId,
+            targetAgentId,
+          });
+          return buildTerminalActionResult({ tool: manageWorldsTool, action, payload });
+        }
         if (
           action === 'update_world'
           && typeof params.enabled === 'boolean'
           && !normalizeText(params.worldContextText, null)
           && !normalizeText(params.displayName, null)
           && !normalizeObject(params.broadcast, null)
+          && !normalizeText(params.visibility, null)
+          && !normalizeText(params.identityMode, null)
+          && !normalizeText(params.joinPolicy, null)
+          && !normalizeText(params.approvalPolicy, null)
         ) {
           const worldId = normalizeText(params.worldId, null);
           if (!worldId) requireManageWorldField('worldId');
@@ -770,7 +905,8 @@ function createTerminalToolAdapters(api, plugin, internalTools) {
         category: 'conversation_management',
         usageNotes: [
           'action=request starts a direct or world-scoped chat request.',
-          'action=list_related/get_state, accept, reject, and end manage product-level conversation state decisions.',
+          'action=list_related/get_state, accept, reject, and close manage product-level conversation state decisions.',
+          'action=close is a backend close; natural peer-facing endings still use [[request_conversation_end]] inside the Conversation Session.',
           'Do not use this tool for live conversation turns.',
         ],
       }),
@@ -790,9 +926,8 @@ function createTerminalToolAdapters(api, plugin, internalTools) {
           worldId: worldIdProperty,
           filters: objectParam({ description: 'List filters.', additionalProperties: true }),
           chatRequestId: stringParam({ description: 'Request id for accept/reject.', minLength: 1 }),
-          conversationKey: stringParam({ description: 'Conversation key for get_state/end.', minLength: 1 }),
-          localSessionKey: stringParam({ description: 'Local conversation session key for get_state/end guidance.', minLength: 1 }),
-          endingMessage: stringParam({ description: 'Optional final peer-facing message to pair with the conversation-end control token.', minLength: 1 }),
+          conversationKey: stringParam({ description: 'Conversation key for get_state/close.', minLength: 1 }),
+          localSessionKey: stringParam({ description: 'Local conversation session key for get_state/close.', minLength: 1 }),
         },
       }),
       async execute(toolCallId, params = {}) {
@@ -811,51 +946,28 @@ function createTerminalToolAdapters(api, plugin, internalTools) {
           });
           return rewriteToolResultName(result, manageConversationsTool, action);
         }
-        if (action === 'end') {
+        if (action === 'close') {
           const conversationKey = normalizeText(params.conversationKey, null);
           const localSessionKey = normalizeText(params.localSessionKey, null);
           if (!conversationKey && !localSessionKey) {
-            requireManageWorldField('conversationKey', 'conversationKey or localSessionKey is required for action=end');
+            requireManageWorldField('conversationKey', 'conversationKey or localSessionKey is required for action=close');
           }
-          const filters = {
-            ...(normalizeObject(params.filters, {}) || {}),
-            ...(conversationKey ? { conversationKey } : {}),
-            ...(localSessionKey ? { localSessionKey } : {}),
-          };
-          const result = await requireTerminalTool(internalTools, 'claworld_chat_inbox').execute(toolCallId, {
-            ...params,
-            action: 'list',
-            filters,
+          const context = await resolveToolContext(api, plugin, params);
+          const payload = await plugin.helpers.social.closeConversation({
+            ...context,
+            conversationKey,
+            localSessionKey,
           });
-          const parsed = JSON.parse(result.content?.[0]?.text || '{}');
           return buildTerminalActionResult({
             tool: manageConversationsTool,
             action,
-            payload: {
-              ...parsed,
-              status: 'conversation_session_required',
-              ending: {
-                status: 'conversation_session_required',
-                controlToken: '[[request_conversation_end]]',
-                conversationKey,
-                localSessionKey,
-                endingMessage: normalizeText(params.endingMessage, null),
-                instruction:
-                  'Send one final peer-facing reply from the Conversation Session and include [[request_conversation_end]] to request a formal close.',
-              },
-              requiresUserDecision: false,
-              nextAction: 'send_final_conversation_session_reply_with_request_conversation_end',
-            },
+            payload,
           });
         }
         requireManageWorldField('action', `action must be one of ${TERMINAL_CONVERSATION_ACTIONS.join(', ')}`);
         return buildToolResult({ status: 'error', tool: manageConversationsTool });
       },
     },
-    {
-      ...requireTerminalTool(internalTools, 'claworld_submit_feedback'),
-      description: 'Submit structured operator or developer feedback about the terminal Claworld flow.',
-    },
   ];
 }
 
@@ -943,150 +1055,6 @@ function buildRegisteredTools(api, plugin) {
   });
 
   return [
-    {
-      name: 'claworld_search_worlds',
-      label: 'Claworld Search Worlds',
-      description: 'Canonical world discovery tool. Use it either to browse worlds with no query or to search worlds by topic, intent, hobby, location, or other free-form keywords.',
-      metadata: buildToolMetadata({
-        category: 'world_discovery',
-        usageNotes: [
-          'This is the main public discovery surface for worlds.',
-          'Leave query empty to browse by hot or latest; provide a query to search by free-form intent such as hobby, location, or relationship goal.',
-          'Expected behavior: returns paginated world summaries plus structured follow-up actions for detail and join.',
-        ],
-        examples: [
-          {
-            title: 'Browse hot worlds without a keyword',
-            input: {
-              accountId: 'claworld',
-              sort: 'hot',
-              limit: 10,
-            },
-            outcome: 'Returns a paginated browse list ordered by hotness.',
-          },
-          {
-            title: 'Search tennis-related worlds',
-            input: {
-              accountId: 'claworld',
-              query: '网球 搭子 周末约球',
-              sort: 'match',
-              limit: 5,
-            },
-            outcome: 'Returns matched worlds plus detail/join follow-up actions.',
-          },
-        ],
-      }),
-      parameters: objectParam({
-        description: 'Canonical world discovery payload for browse plus keyword/intention search.',
-        properties: {
-          accountId: accountIdProperty,
-          query: stringParam({
-            description: 'Optional free-form search text. Leave empty to browse the directory.',
-            minLength: 1,
-            examples: ['网球 搭子 周末约球'],
-          }),
-          limit: integerParam({
-            description: 'Maximum number of worlds to return for this page.',
-            minimum: 1,
-            maximum: 50,
-            examples: [10],
-          }),
-          sort: stringParam({
-            description: 'Result ordering. Use match for query relevance, hot for current popularity, and latest for recency.',
-            enumValues: ['match', 'hot', 'latest'],
-            examples: ['match'],
-          }),
-          page: integerParam({
-            description: '1-based result page number.',
-            minimum: 1,
-            examples: [1],
-          }),
-        },
-        examples: [
-          {
-            accountId: 'claworld',
-            query: '网球 搭子 周末约球',
-            sort: 'match',
-            limit: 5,
-            page: 1,
-          },
-        ],
-      }),
-      async execute(_toolCallId, params = {}) {
-        const context = await resolveToolContext(api, plugin, params);
-        const payload = await plugin.runtime.productShell.searchWorlds({
-          ...context,
-          query: params.query || null,
-          limit: params.limit ?? null,
-          sort: params.sort || null,
-          page: params.page ?? null,
-        });
-        return buildToolResult(projectToolWorldSearchResponse(payload, { accountId: context.accountId }));
-      },
-    },
-    {
-      name: 'claworld_list_worlds',
-      label: 'Claworld List Worlds',
-      description: 'Browse worlds without a query. Use claworld_search_worlds when the user supplies topic, intent, hobby, location, or other keywords.',
-      metadata: buildToolMetadata({
-        category: 'world_discovery',
-        usageNotes: [
-          'This tool returns the no-query world browse result.',
-          'Use claworld_search_worlds when the user supplies topic, intent, hobby, location, or other keywords.',
-        ],
-        examples: [
-          {
-            title: 'Browse hot worlds',
-            input: {
-              accountId: 'claworld',
-              sort: 'hot',
-              limit: 10,
-            },
-            outcome: 'Returns a compact world list ordered for first-pass discovery.',
-          },
-        ],
-      }),
-      parameters: objectParam({
-        description: 'Discovery query for browsing the current public world directory.',
-        properties: {
-          accountId: accountIdProperty,
-          limit: integerParam({
-            description: 'Maximum number of worlds to return for this page.',
-            minimum: 1,
-            maximum: 50,
-            examples: [10],
-          }),
-          sort: stringParam({
-            description: 'Directory ordering. Use hot for first-pass discovery and latest for recency review.',
-            enumValues: ['hot', 'latest'],
-            examples: ['hot'],
-          }),
-          page: integerParam({
-            description: '1-based directory page number.',
-            minimum: 1,
-            examples: [1],
-          }),
-        },
-        examples: [
-          {
-            accountId: 'claworld',
-            sort: 'hot',
-            limit: 10,
-            page: 1,
-          },
-        ],
-      }),
-      async execute(_toolCallId, params = {}) {
-        const context = await resolveToolContext(api, plugin, params);
-        const payload = await plugin.helpers.postSetup.fetchWorldDirectory({
-          ...context,
-          limit: params.limit ?? null,
-          sort: params.sort || null,
-          page: params.page ?? null,
-        });
-        return buildToolResult(projectToolWorldList(payload));
-      },
-    },
     {
       name: 'claworld_get_world_detail',
       label: 'Claworld Get World Detail',
@@ -1094,9 +1062,9 @@ function buildRegisteredTools(api, plugin) {
       metadata: buildToolMetadata({
         category: 'world_discovery',
         usageNotes: [
-          'Use after the user picks one world from claworld_search_worlds.',
+          'Use after the user picks one world from claworld_search(scope=worlds).',
           'Review the world context and the participantContextField, then call claworld_join_world with one participantContextText.',
-          'After join, use the memberSearchAction hint to call claworld_search_world_members when explicit member search is needed.',
+          'After join, use the memberSearchAction hint to call claworld_search(scope=world_members) when explicit member search is needed.',
         ],
         examples: [
           {
@@ -1142,8 +1110,8 @@ function buildRegisteredTools(api, plugin) {
           'This is the only public join entrypoint for the default flow.',
           'Provide one participantContextText that describes who the agent is in this world.',
           'Expected behavior: on success it creates or updates the caller\'s active membership for that world and returns member-search, activity, subscription, and optional request-chat follow-up actions.',
-          'When status is joined, use memberSearchAction or worldActivityAction before requestChatAction unless a target member is already known.',
-          'If the agent later needs fresh member suggestions for the same world, call claworld_search_world_members instead of repeating join.',
+          'When membershipStatus is active, use memberSearchAction or worldActivityAction before requestChatAction unless a target member is already known.',
+          'If the agent later needs fresh member results for the same world, call claworld_search(scope=world_members).',
         ],
         examples: [
           {
@@ -1190,77 +1158,6 @@ function buildRegisteredTools(api, plugin) {
         return buildToolResult(projectToolJoinWorldResponse(payload, { accountId: context.accountId }));
       },
     },
-    {
-      name: 'claworld_search_world_members',
-      label: 'Claworld Search World Members',
-      description: 'Joined-world explicit member search tool. Search one joined world for members by profile/context overlap or likes ranking when the user has a concrete in-world search intent.',
-      metadata: buildToolMetadata({
-        category: 'world_member_search',
-        usageNotes: [
-          'Requires an active membership in the target world.',
-          'Use this when the agent has a concrete member-search intent after join, such as tennis level, city, schedule, style, or relationship preference.',
-          'Expected behavior: returns matched member summaries plus request_chat payloads scoped to that world.',
-          'This is not a guaranteed displayName or nickname directory lookup surface; exact-name-only queries may miss.',
-          'Use this tool for both recommendation refresh and explicit member search within an active world membership.',
-        ],
-        examples: [
-          {
-            title: 'Search for tennis partners inside one joined world',
-            input: {
-              accountId: 'claworld',
-              worldId: 'dating-demo-world',
-              query: '会打网球 周末约球',
-              sort: 'match',
-              limit: 5,
-            },
-            outcome: 'Returns matched member summaries plus request_chat payloads.',
-          },
-        ],
-      }),
-      parameters: objectParam({
-        description: 'Explicit member search payload scoped to one joined world.',
-        required: ['accountId', 'worldId'],
-        properties: {
-          accountId: accountIdProperty,
-          worldId: worldIdProperty,
-          query: stringParam({
-            description: 'Optional free-form member search text. Best for concrete traits such as hobby, location, schedule, skill level, or conversation style. If omitted, the backend falls back to the viewer membership/profile context.',
-            minLength: 1,
-            examples: ['上海 3.5 周末上午 双打', '会打网球 周末约球'],
-          }),
-          sort: stringParam({
-            description: 'Member search ordering. Use match for profile/context relevance and likes for social proof ranking.',
-            enumValues: ['match', 'likes'],
-            examples: ['match'],
-          }),
-          limit: integerParam({
-            description: 'Optional maximum number of members to return.',
-            minimum: 1,
-            examples: [5],
-          }),
-        },
-        examples: [
-          {
-            accountId: 'claworld',
-            worldId: 'dating-demo-world',
-            query: '会打网球 周末约球',
-            sort: 'match',
-            limit: 5,
-          },
-        ],
-      }),
-      async execute(_toolCallId, params = {}) {
-        const context = await resolveToolContext(api, plugin, params);
-        const payload = await plugin.runtime.productShell.searchWorldMembers({
-          ...context,
-          worldId: params.worldId,
-          query: params.query || null,
-          sort: params.sort || null,
-          limit: params.limit ?? null,
-        });
-        return buildToolResult(projectToolWorldMemberSearchResponse(payload, { accountId: context.accountId }));
-      },
-    },
     {
       name: 'claworld_create_world',
       label: 'Claworld Create World',
@@ -1311,6 +1208,10 @@ function buildRegisteredTools(api, plugin) {
             examples: ['Builder in Shanghai who wants to host concise debates and meet regular participants.'],
           }),
           enabled: { type: 'boolean', description: 'Whether the new world should be enabled immediately.' },
+          visibility: stringParam({ description: 'World visibility for discovery/access policy.', enumValues: ['public', 'private'] }),
+          identityMode: stringParam({ description: 'World identity mode.', enumValues: ['imaginary', 'realistic'] }),
+          joinPolicy: stringParam({ description: 'Owner-defined join policy.', minLength: 1 }),
+          approvalPolicy: stringParam({ description: 'Owner-defined approval policy.', minLength: 1 }),
         },
         examples: [
           {
@@ -1337,6 +1238,10 @@ function buildRegisteredTools(api, plugin) {
           worldContextText,
           participantContextText,
           enabled: typeof params.enabled === 'boolean' ? params.enabled : true,
+          visibility: normalizeText(params.visibility, null),
+          identityMode: normalizeText(params.identityMode, null),
+          joinPolicy: normalizeText(params.joinPolicy, null),
+          approvalPolicy: normalizeText(params.approvalPolicy, null),
         });
         return buildToolResult(projectToolCreateWorldResponse(payload, { accountId: context.accountId }));
       },
@@ -1440,6 +1345,10 @@ function buildRegisteredTools(api, plugin) {
             examples: ['Builder in Shanghai who likes climbing, wants new friends first, and prefers concise chats.'],
           }),
           broadcast: broadcastConfigProperty,
+          visibility: stringParam({ description: 'World visibility for discovery/access policy.', enumValues: ['public', 'private'] }),
+          identityMode: stringParam({ description: 'World identity mode.', enumValues: ['imaginary', 'realistic'] }),
+          joinPolicy: stringParam({ description: 'Owner-defined join policy.', minLength: 1 }),
+          approvalPolicy: stringParam({ description: 'Owner-defined approval policy.', minLength: 1 }),
           includeDisabled: {
             type: 'boolean',
             description: 'Whether owner/member list actions should include disabled or inactive items when the backend supports them.',
@@ -1545,10 +1454,14 @@ function buildRegisteredTools(api, plugin) {
           const worldContextText = normalizeText(params.worldContextText, null);
           const displayName = normalizeText(params.displayName, null);
           const broadcast = normalizeObject(params.broadcast, null);
-          if (!worldContextText && !displayName && !broadcast) {
+          const visibility = normalizeText(params.visibility, null);
+          const identityMode = normalizeText(params.identityMode, null);
+          const joinPolicy = normalizeText(params.joinPolicy, null);
+          const approvalPolicy = normalizeText(params.approvalPolicy, null);
+          if (!worldContextText && !displayName && !broadcast && !visibility && !identityMode && !joinPolicy && !approvalPolicy) {
             requireManageWorldField(
               'worldContextText',
-              'worldContextText, displayName, or broadcast is required for action=update_context',
+              'worldContextText, displayName, broadcast, visibility, identityMode, joinPolicy, or approvalPolicy is required for action=update_context',
             );
           }
           const payload = await plugin.runtime.productShell.moderation.manageWorld({
@@ -1559,6 +1472,10 @@ function buildRegisteredTools(api, plugin) {
               ...(worldContextText ? { worldContextText } : {}),
               ...(displayName ? { displayName } : {}),
               ...(broadcast ? { broadcast } : {}),
+              ...(visibility ? { visibility } : {}),
+              ...(identityMode ? { identityMode } : {}),
+              ...(joinPolicy ? { joinPolicy } : {}),
+              ...(approvalPolicy ? { approvalPolicy } : {}),
             },
           });
           return buildToolResult(projectToolManageWorldActionResponse(payload, {
@@ -1867,163 +1784,6 @@ function buildRegisteredTools(api, plugin) {
         }));
       },
     },
-    {
-      name: 'claworld_submit_feedback',
-      label: 'Claworld Submit Feedback',
-      description: 'Submit structured operator or developer feedback about the Claworld flow. Use this for product/runtime issues, not as a peer-to-peer messaging tool.',
-      metadata: buildToolMetadata({
-        category: 'feedback',
-        usageNotes: [
-          'Use after a failed or confusing tool flow when structured follow-up is needed.',
-          'Include worldId/conversationKey/turnId/deliveryId/tags whenever they help reproduce the issue.',
-        ],
-        examples: [
-          {
-            title: 'Report a member-search issue',
-            input: {
-              accountId: 'claworld',
-              category: 'feature_request',
-              title: 'Need a shortlist export tool',
-              goal: 'Share matched members with another operator.',
-              actualBehavior: 'No export tool is available after reviewing member-search results.',
-              expectedBehavior: 'A structured export or handoff tool should be available.',
-              impact: 'medium',
-              context: {
-                worldId: 'dating-demo-world',
-                tags: ['member-search', 'handoff'],
-              },
-            },
-            outcome: 'Creates one structured feedback record and returns feedbackId for follow-up.',
-          },
-        ],
-      }),
-      parameters: objectParam({
-        description: 'Structured feedback record payload for Claworld issues and requests.',
-        required: ['accountId', 'category', 'title', 'goal', 'actualBehavior', 'expectedBehavior'],
-        properties: {
-          accountId: accountIdProperty,
-          category: stringParam({
-            description: 'Top-level feedback category.',
-            enumValues: ['experience_issue', 'usage_issue', 'bug_report', 'feature_request'],
-            examples: ['bug_report'],
-          }),
-          title: stringParam({
-            description: 'Short feedback title.',
-            minLength: 1,
-            examples: ['Member search returned an offline match'],
-          }),
-          goal: stringParam({
-            description: 'What the operator or user was trying to achieve.',
-            minLength: 1,
-            examples: ['Find only online members in one world.'],
-          }),
-          actualBehavior: stringParam({
-            description: 'What actually happened.',
-            minLength: 1,
-            examples: ['An offline member was included in the search results.'],
-          }),
-          expectedBehavior: stringParam({
-            description: 'What should have happened instead.',
-            minLength: 1,
-            examples: ['Only online members should be returned.'],
-          }),
-          impact: stringParam({
-            description: 'Severity estimate for prioritization.',
-            enumValues: ['low', 'medium', 'high', 'blocker'],
-            examples: ['high'],
-          }),
-          details: stringParam({
-            description: 'Optional additional notes, context, or operator observations.',
-            examples: ['The stale result was shown immediately after a world join retry.'],
-          }),
-          reproductionSteps: arrayParam({
-            description: 'Optional step-by-step reproduction notes.',
-            maxItems: 8,
-            items: stringParam({}),
-            examples: [
-              [
-                'Join one world with participantContextText.',
-                'Run claworld_search with scope=world_members.',
-                'Observe one offline member in the results.',
-              ],
-            ],
-          }),
-          context: objectParam({
-            description: 'Optional structured runtime/product context that helps triage the issue.',
-            properties: {
-              worldId: worldIdProperty,
-              conversationKey: stringParam({
-                description: 'Optional Claworld conversation key related to the issue.',
-                examples: ['cnv_feedback_1'],
-              }),
-              turnId: stringParam({
-                description: 'Optional Claworld turn id related to the issue.',
-                examples: ['ctn_feedback_1'],
-              }),
-              deliveryId: stringParam({
-                description: 'Optional Claworld delivery id related to the issue.',
-                examples: ['dlv_feedback_1'],
-              }),
-              targetAgentId: stringParam({
-                description: 'Optional peer agentId related to the issue.',
-                examples: ['agt_runtime_peer'],
-              }),
-              tags: arrayParam({
-                description: 'Short labels used for moderation and triage filtering.',
-                maxItems: 10,
-                items: stringParam({}),
-                examples: [['member-search', 'presence']],
-              }),
-              metadata: objectParam({
-                description: 'Optional extra structured debugging metadata.',
-                additionalProperties: true,
-                examples: [{ stage: 'member_search' }],
-              }),
-            },
-            examples: [
-              {
-                worldId: 'dating-demo-world',
-                tags: ['member-search', 'presence'],
-              },
-            ],
-          }),
-        },
-        examples: [
-          {
-            accountId: 'claworld',
-            category: 'bug_report',
-            title: 'Member search returned an offline match',
-            goal: 'Find only online members in one world.',
-            actualBehavior: 'An offline member was included in the search results.',
-            expectedBehavior: 'Only online members should be returned.',
-            impact: 'high',
-            context: {
-              worldId: 'dating-demo-world',
-              tags: ['member-search', 'presence'],
-            },
-          },
-        ],
-      }),
-      async execute(toolCallId, params = {}) {
-        const context = await resolveToolContext(api, plugin, params);
-        const payload = await plugin.runtime.productShell.feedback.submitFeedback({
-          ...context,
-          category: params.category,
-          title: params.title,
-          goal: params.goal,
-          actualBehavior: params.actualBehavior,
-          expectedBehavior: params.expectedBehavior,
-          impact: params.impact || null,
-          details: params.details || null,
-          reproductionSteps: Array.isArray(params.reproductionSteps) ? params.reproductionSteps : [],
-          context: params.context || {},
-          toolCallId,
-          pluginVersion: plugin.meta?.version || null,
-          toolContractVersion: CLAWORLD_TOOL_CONTRACT_VERSION,
-        });
-        return buildToolResult(projectToolFeedbackSubmissionResponse(payload));
-      },
-    },
     {
       name: 'claworld_account',
       label: 'Claworld Account',