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

package/src/openclaw/plugin/register.js

@@ -511,42 +511,10 @@ 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: ['relevance', 'hot', 'latest', 'likes', 'activity'],
-            examples: ['relevance'],
+            enumValues: ['match', 'hot', 'latest', 'likes'],
+            examples: ['match'],
           }),
           limit: integerParam({
             description: 'Maximum result count.',
@@ -561,8 +529,8 @@ function createTerminalToolAdapters(api, plugin, internalTools) {
           }),
         },
         examples: [
-          { 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: 'worlds', query: '网球', sort: 'match', limit: 5 },
+          { accountId: 'claworld', scope: 'world_members', worldId: 'dating-demo-world', query: '上海 周末', limit: 5 },
           { accountId: 'claworld', scope: 'people', query: 'Moza', limit: 5 },
           { accountId: 'claworld', scope: 'mixed', query: '网球 Moza', limit: 5 },
         ],
@@ -581,13 +549,6 @@ 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,
@@ -598,7 +559,7 @@ function createTerminalToolAdapters(api, plugin, internalTools) {
     {
       name: publicProfileTool,
       label: 'Claworld Get Public Profile',
-      description: 'Read the current account public profile or perform exact displayName#code public-profile lookup.',
+      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.',
       metadata: buildToolMetadata({
         category: 'public_profile',
         usageNotes: [
@@ -610,27 +571,13 @@ 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: 'Public code paired with displayName for action=lookup_profile.',
+            description: 'Optional public code for a future target lookup route.',
             minLength: 1,
             examples: ['ZX82QP'],
           }),
           displayName: stringParam({
-            description: 'Display name paired with agentCode for action=lookup_profile.',
+            description: 'Optional display name paired with agentCode for a future target lookup route.',
             minLength: 1,
             examples: ['Runtime Peer'],
           }),
@@ -645,31 +592,11 @@ function createTerminalToolAdapters(api, plugin, internalTools) {
         },
       }),
       async execute(toolCallId, params = {}) {
-        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 });
+        const result = await requireTerminalTool(internalTools, 'claworld_account').execute(toolCallId, {
+          ...params,
+          action: 'view',
+        });
+        return rewriteToolResultName(result, publicProfileTool);
       },
     },
     {
@@ -683,6 +610,7 @@ 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({
@@ -704,10 +632,6 @@ 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 }),
@@ -802,10 +726,6 @@ function createTerminalToolAdapters(api, plugin, internalTools) {
           && !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');
@@ -932,6 +852,10 @@ function createTerminalToolAdapters(api, plugin, internalTools) {
         return buildToolResult({ status: 'error', tool: manageConversationsTool });
       },
     },
+    {
+      ...requireTerminalTool(internalTools, 'claworld_submit_feedback'),
+      description: 'Submit structured operator or developer feedback about the terminal Claworld flow.',
+    },
   ];
 }
 
@@ -1019,6 +943,150 @@ 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',
@@ -1026,9 +1094,9 @@ function buildRegisteredTools(api, plugin) {
       metadata: buildToolMetadata({
         category: 'world_discovery',
         usageNotes: [
-          'Use after the user picks one world from claworld_search(scope=worlds).',
+          'Use after the user picks one world from claworld_search_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(scope=world_members) when explicit member search is needed.',
+          'After join, use the memberSearchAction hint to call claworld_search_world_members when explicit member search is needed.',
         ],
         examples: [
           {
@@ -1075,7 +1143,7 @@ function buildRegisteredTools(api, plugin) {
           '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 results for the same world, call claworld_search(scope=world_members).',
+          'If the agent later needs fresh member suggestions for the same world, call claworld_search_world_members instead of repeating join.',
         ],
         examples: [
           {
@@ -1122,6 +1190,77 @@ 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',
@@ -1172,10 +1311,6 @@ 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: [
           {
@@ -1202,10 +1337,6 @@ 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 }));
       },
@@ -1309,10 +1440,6 @@ 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.',
@@ -1418,14 +1545,10 @@ function buildRegisteredTools(api, plugin) {
           const worldContextText = normalizeText(params.worldContextText, null);
           const displayName = normalizeText(params.displayName, null);
           const broadcast = normalizeObject(params.broadcast, null);
-          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) {
+          if (!worldContextText && !displayName && !broadcast) {
             requireManageWorldField(
               'worldContextText',
-              'worldContextText, displayName, broadcast, visibility, identityMode, joinPolicy, or approvalPolicy is required for action=update_context',
+              'worldContextText, displayName, or broadcast is required for action=update_context',
             );
           }
           const payload = await plugin.runtime.productShell.moderation.manageWorld({
@@ -1436,10 +1559,6 @@ function buildRegisteredTools(api, plugin) {
               ...(worldContextText ? { worldContextText } : {}),
               ...(displayName ? { displayName } : {}),
               ...(broadcast ? { broadcast } : {}),
-              ...(visibility ? { visibility } : {}),
-              ...(identityMode ? { identityMode } : {}),
-              ...(joinPolicy ? { joinPolicy } : {}),
-              ...(approvalPolicy ? { approvalPolicy } : {}),
             },
           });
           return buildToolResult(projectToolManageWorldActionResponse(payload, {
@@ -1748,6 +1867,163 @@ 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',

package/src/openclaw/runtime/feedback-helper.js

@@ -124,10 +124,10 @@ export async function submitFeedbackReport({
         tags: normalizeStringList(normalizedContext.tags),
         metadata: normalizeObject(normalizedContext.metadata),
       },
-      source: 'openclaw_runtime',
+      source: 'openclaw_tool',
       runtimeContext: {
         channelId: 'claworld',
-        toolName: 'claworld_feedback_helper',
+        toolName: 'claworld_submit_feedback',
         toolCallId: normalizeText(toolCallId, null),
         ...diagnostics,
         toolContractVersion: normalizeText(toolContractVersion, null),