@xfxstudio/claworld 0.2.7 → 0.2.9

package/openclaw.plugin.json

@@ -8,7 +8,7 @@
   ],
   "name": "Claworld Persona Relay",
   "description": "Claworld relay world channel plugin for OpenClaw.",
-  "version": "0.2.7",
+  "version": "0.2.9",
   "configSchema": {
     "type": "object",
     "additionalProperties": false,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xfxstudio/claworld",
-  "version": "0.2.7",
+  "version": "0.2.9",
   "description": "Claworld channel plugin for OpenClaw",
   "type": "module",
   "main": "index.js",

package/src/openclaw/installer/doctor.js

@@ -6,8 +6,11 @@ import {
   DEFAULT_CLAWORLD_AGENT_ID,
   DEFAULT_CLAWORLD_SERVER_URL,
   expandUserPath,
+  getEffectiveAgentSandboxMode,
+  MIN_MANAGED_SESSION_VISIBILITY,
   normalizeText,
   resolveClaworldManagedRuntimeOptions,
+  sandboxModeNeedsSessionToolsVisibility,
 } from '../plugin/managed-config.js';
 import {
   CLAWORLD_DOCTOR_COMMAND,
@@ -87,6 +90,18 @@ function findChannelAccount(channelStatus, accountId) {
   return entries.find((entry) => entry?.accountId === accountId) || null;
 }
 
+const SESSION_VISIBILITY_RANK = Object.freeze({
+  self: 0,
+  tree: 1,
+  agent: 2,
+  all: 3,
+});
+
+function resolveConfiguredSessionVisibility(config = {}) {
+  const visibility = normalizeText(config?.tools?.sessions?.visibility, null);
+  return Object.prototype.hasOwnProperty.call(SESSION_VISIBILITY_RANK, visibility) ? visibility : null;
+}
+
 function normalizeGatewayBaseUrl(gatewayStatus) {
   const probeUrl = normalizeText(gatewayStatus?.gateway?.probeUrl, null);
   if (probeUrl) {
@@ -455,6 +470,54 @@ export async function runClaworldDoctor({
     details: { issues: configuredAccount.issues },
   }));
 
+  const configuredSessionVisibility = resolveConfiguredSessionVisibility(config);
+  const sessionVisibilityHealthy = (
+    configuredSessionVisibility != null
+    && SESSION_VISIBILITY_RANK[configuredSessionVisibility] >= SESSION_VISIBILITY_RANK[MIN_MANAGED_SESSION_VISIBILITY]
+  );
+  checks.push(createCheck({
+    id: 'session-tools-visibility',
+    category: 'Managed config',
+    label: 'Session tool visibility',
+    status: sessionVisibilityHealthy ? 'pass' : 'warn',
+    summary: sessionVisibilityHealthy
+      ? `tools.sessions.visibility is \`${configuredSessionVisibility}\`, which satisfies the managed same-agent minimum \`${MIN_MANAGED_SESSION_VISIBILITY}\`.`
+      : `tools.sessions.visibility is \`${configuredSessionVisibility || 'missing'}\`, but the managed same-agent follow-up path needs at least \`${MIN_MANAGED_SESSION_VISIBILITY}\`.`,
+    action: sessionVisibilityHealthy
+      ? null
+      : `Rerun \`${CLAWORLD_INSTALLER_COMMAND}\` to raise session visibility for managed same-agent follow-up routing.`,
+    details: {
+      actualVisibility: configuredSessionVisibility,
+      minimumVisibility: MIN_MANAGED_SESSION_VISIBILITY,
+    },
+  }));
+
+  const effectiveSandboxMode = getEffectiveAgentSandboxMode(config, resolvedAgentId);
+  if (sandboxModeNeedsSessionToolsVisibility(effectiveSandboxMode)) {
+    const sandboxSessionToolsVisibility = normalizeText(
+      config?.agents?.defaults?.sandbox?.sessionToolsVisibility,
+      null,
+    );
+    const sandboxVisibilityHealthy = sandboxSessionToolsVisibility === 'all';
+    checks.push(createCheck({
+      id: 'sandbox-session-tools-visibility',
+      category: 'Managed config',
+      label: 'Sandbox session tool visibility',
+      status: sandboxVisibilityHealthy ? 'pass' : 'warn',
+      summary: sandboxVisibilityHealthy
+        ? `Effective sandbox mode is \`${effectiveSandboxMode}\` and agents.defaults.sandbox.sessionToolsVisibility is correctly set to \`all\`.`
+        : `Effective sandbox mode is \`${effectiveSandboxMode}\`, so agents.defaults.sandbox.sessionToolsVisibility should be \`all\` (currently \`${sandboxSessionToolsVisibility || 'missing'}\`).`,
+      action: sandboxVisibilityHealthy
+        ? null
+        : `Rerun \`${CLAWORLD_INSTALLER_COMMAND}\` to widen sandbox session-tool visibility for managed follow-up routing.`,
+      details: {
+        effectiveSandboxMode,
+        sessionToolsVisibility: sandboxSessionToolsVisibility,
+        requiredSessionToolsVisibility: 'all',
+      },
+    }));
+  }
+
   checks.push(createCheck({
     id: 'app-token',
     category: 'Credentials and runtime',

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

@@ -720,6 +720,34 @@ async function acceptChatRequest({
   return result.body || {};
 }
 
+async function rejectChatRequest({
+  runtimeConfig,
+  actorAgentId,
+  chatRequestId,
+  fetchImpl,
+}) {
+  const baseUrl = normalizeRelayHttpBaseUrl(runtimeConfig.serverUrl);
+  const result = await fetchJson(fetchImpl, `${baseUrl}/v1/chat-requests/${encodeURIComponent(chatRequestId)}/reject`, {
+    method: 'POST',
+    headers: {
+      'content-type': 'application/json',
+      ...(runtimeConfig.apiKey ? { 'x-api-key': runtimeConfig.apiKey } : {}),
+      ...buildRuntimeAuthHeaders(runtimeConfig),
+    },
+    body: JSON.stringify({ actorAgentId }),
+  });
+  if (!result.ok) {
+    createRelayRouteError({
+      result,
+      runtimeConfig,
+      code: 'chat_request_reject_failed',
+      publicMessage: 'failed to reject chat request',
+      context: { actorAgentId, chatRequestId },
+    });
+  }
+  return result.body || {};
+}
+
 async function syncChatRequestApprovalPolicy({
   runtimeConfig,
   fetchImpl,
@@ -1472,6 +1500,7 @@ function createDeliveryReplyDispatcher({
   });
 
   const markDispatchIdle = async () => {
+    await dispatchApi.dispatcher.waitForIdle?.();
     if (!replied && !suppressed) {
       const continuation = buildRelayContinuationText({
         finalTexts,
@@ -2539,6 +2568,15 @@ export function createClaworldChannelPlugin({
             fetchImpl,
           });
         },
+        rejectChatRequest: async (context = {}) => {
+          const resolvedContext = await resolveBoundRuntimeContext(context);
+          return rejectChatRequest({
+            runtimeConfig: resolvedContext.runtimeConfig,
+            actorAgentId: resolvedContext.agentId || null,
+            chatRequestId: context.chatRequestId || null,
+            fetchImpl,
+          });
+        },
       },
       postSetup: {
         fetchWorldDirectory: async (context = {}) => {
@@ -2676,6 +2714,7 @@ export function createClaworldChannelPlugin({
             mode: context.mode || 'get',
             changes: context.changes || null,
             enabled: Object.prototype.hasOwnProperty.call(context, 'enabled') ? context.enabled : null,
+            status: context.status || null,
             fetchImpl,
             logger,
           });
@@ -2864,6 +2903,7 @@ export function createClaworldChannelPlugin({
               mode: context.mode || 'get',
               changes: context.changes || null,
               enabled: Object.prototype.hasOwnProperty.call(context, 'enabled') ? context.enabled : null,
+              status: context.status || null,
               fetchImpl,
               logger,
             });

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

@@ -23,6 +23,8 @@ export const DEFAULT_CLAWORLD_APPROVAL_MODE = DEFAULT_CHAT_REQUEST_APPROVAL_POLI
 export const DEFAULT_CLAWORLD_SESSION_TARGET = 'mainagent';
 export const DEFAULT_CLAWORLD_FALLBACK_TARGET = 'mainagent';
 export const CLAWORLD_PLUGIN_TOOL_ALLOW_ENTRY = 'claworld';
+export const MIN_MANAGED_SESSION_VISIBILITY = 'agent';
+export const REQUIRED_SANDBOX_SESSION_TOOLS_VISIBILITY = 'all';
 
 export const TOOL_PROFILES = CLAWORLD_TOOL_PROFILES;
 
@@ -128,6 +130,109 @@ function findManagedAccountEntry(config = {}, accountId) {
   return {};
 }
 
+const SESSION_VISIBILITY_RANK = Object.freeze({
+  self: 0,
+  tree: 1,
+  agent: 2,
+  all: 3,
+});
+
+const SANDBOX_SESSION_TOOLS_VISIBILITY_RANK = Object.freeze({
+  spawned: 0,
+  all: 1,
+});
+
+function normalizeSessionVisibility(value, fallback = null) {
+  const normalized = normalizeText(value, fallback);
+  return Object.prototype.hasOwnProperty.call(SESSION_VISIBILITY_RANK, normalized)
+    ? normalized
+    : fallback;
+}
+
+function normalizeSandboxSessionToolsVisibility(value, fallback = null) {
+  const normalized = normalizeText(value, fallback);
+  return Object.prototype.hasOwnProperty.call(SANDBOX_SESSION_TOOLS_VISIBILITY_RANK, normalized)
+    ? normalized
+    : fallback;
+}
+
+function compareRankedSetting(value, target, rankMap) {
+  const nextValue = normalizeText(value, null);
+  const nextTarget = normalizeText(target, null);
+  const valueRank = Object.prototype.hasOwnProperty.call(rankMap, nextValue) ? rankMap[nextValue] : null;
+  const targetRank = Object.prototype.hasOwnProperty.call(rankMap, nextTarget) ? rankMap[nextTarget] : null;
+  if (valueRank == null && targetRank == null) return 0;
+  if (valueRank == null) return -1;
+  if (targetRank == null) return 1;
+  return valueRank - targetRank;
+}
+
+export function getEffectiveAgentSandboxMode(config = {}, agentId = DEFAULT_CLAWORLD_AGENT_ID) {
+  const normalizedAgentId = normalizeText(agentId, DEFAULT_CLAWORLD_AGENT_ID);
+  const agentEntry = findAgentEntry(config, normalizedAgentId);
+  const agentSandboxMode = normalizeText(agentEntry?.sandbox?.mode, null);
+  if (agentSandboxMode) return agentSandboxMode;
+  return normalizeText(config?.agents?.defaults?.sandbox?.mode, 'off');
+}
+
+export function sandboxModeNeedsSessionToolsVisibility(mode) {
+  return mode === 'all' || mode === 'non-main';
+}
+
+function ensureManagedSessionRoutingVisibility(config = {}, {
+  agentId = DEFAULT_CLAWORLD_AGENT_ID,
+  summary = [],
+} = {}) {
+  config.tools = ensureObject(config.tools);
+  const existingSessionTools = ensureObject(config.tools.sessions);
+  const existingVisibility = normalizeSessionVisibility(existingSessionTools.visibility, null);
+  if (compareRankedSetting(existingVisibility, MIN_MANAGED_SESSION_VISIBILITY, SESSION_VISIBILITY_RANK) < 0) {
+    config.tools.sessions = {
+      ...existingSessionTools,
+      visibility: MIN_MANAGED_SESSION_VISIBILITY,
+    };
+    summary.push(
+      existingVisibility
+        ? `tools.sessions.visibility raised from ${existingVisibility} to ${MIN_MANAGED_SESSION_VISIBILITY}`
+        : `tools.sessions.visibility set to ${MIN_MANAGED_SESSION_VISIBILITY}`,
+    );
+  } else if (Object.keys(existingSessionTools).length > 0) {
+    config.tools.sessions = existingSessionTools;
+  }
+
+  const effectiveSandboxMode = getEffectiveAgentSandboxMode(config, agentId);
+  if (!sandboxModeNeedsSessionToolsVisibility(effectiveSandboxMode)) {
+    return;
+  }
+
+  config.agents = ensureObject(config.agents);
+  config.agents.defaults = ensureObject(config.agents.defaults);
+  const existingSandbox = ensureObject(config.agents.defaults.sandbox);
+  const existingSessionToolsVisibility = normalizeSandboxSessionToolsVisibility(
+    existingSandbox.sessionToolsVisibility,
+    null,
+  );
+  if (
+    compareRankedSetting(
+      existingSessionToolsVisibility,
+      REQUIRED_SANDBOX_SESSION_TOOLS_VISIBILITY,
+      SANDBOX_SESSION_TOOLS_VISIBILITY_RANK,
+    ) < 0
+  ) {
+    config.agents.defaults.sandbox = {
+      ...existingSandbox,
+      sessionToolsVisibility: REQUIRED_SANDBOX_SESSION_TOOLS_VISIBILITY,
+    };
+    summary.push(
+      existingSessionToolsVisibility
+        ? `agents.defaults.sandbox.sessionToolsVisibility raised from ${existingSessionToolsVisibility} to ${REQUIRED_SANDBOX_SESSION_TOOLS_VISIBILITY}`
+        : `agents.defaults.sandbox.sessionToolsVisibility set to ${REQUIRED_SANDBOX_SESSION_TOOLS_VISIBILITY}`,
+    );
+  } else if (Object.keys(existingSandbox).length > 0) {
+    config.agents.defaults.sandbox = existingSandbox;
+  }
+}
+
 function inferExistingAgentId(config = {}, accountId = DEFAULT_CLAWORLD_ACCOUNT_ID) {
   const bindings = Array.isArray(config?.bindings) ? config.bindings : [];
   const bindingMatch = bindings
@@ -716,6 +821,11 @@ export function applyClaworldManagedRuntimeConfig(inputConfig = {}, options = {}
       : `reconciled claworld binding for ${options.accountId}`,
   );
 
+  ensureManagedSessionRoutingVisibility(config, {
+    agentId: options.agentId,
+    summary,
+  });
+
   return {
     config,
     summary,

package/src/openclaw/plugin/register.js

@@ -266,6 +266,56 @@ function buildToolMetadata({
   };
 }
 
+const MANAGE_WORLD_ACTIONS = Object.freeze([
+  'list',
+  'get',
+  'update_context',
+  'pause',
+  'close',
+  'resume',
+]);
+
+function normalizeManageWorldAction(value, fallback = null) {
+  const normalized = normalizeText(value, fallback);
+  return MANAGE_WORLD_ACTIONS.includes(normalized) ? normalized : fallback;
+}
+
+function inferManageWorldAction(params = {}) {
+  const explicitAction = normalizeManageWorldAction(params.action, null);
+  if (explicitAction) return explicitAction;
+  if (!normalizeText(params.worldId, null)) return 'list';
+  if (normalizeText(params.worldContextText, null) || normalizeText(params.displayName, null)) {
+    return 'update_context';
+  }
+  return 'get';
+}
+
+function requireManageWorldField(fieldId, message = `${fieldId} is required`) {
+  throw createRuntimeBoundaryError({
+    code: 'tool_input_invalid',
+    category: 'input',
+    status: 400,
+    message,
+    publicMessage: message,
+    recoverable: true,
+    context: { field: fieldId },
+  });
+}
+
+function projectToolManageWorldActionResponse(payload = {}, { accountId = null, action = null } = {}) {
+  const resolvedAction = normalizeManageWorldAction(action, null) || 'get';
+  if (resolvedAction === 'list') {
+    return {
+      action: resolvedAction,
+      ...projectToolOwnedWorldsResponse(payload, { accountId }),
+    };
+  }
+  return {
+    action: resolvedAction,
+    ...projectToolManagedWorldResponse(payload, { accountId }),
+  };
+}
+
 function buildRegisteredTools(api, plugin) {
   const accountIdProperty = stringParam({
     description: 'Claworld account id to execute the tool against. In managed installs this is usually the dedicated claworld account.',
@@ -509,67 +559,31 @@ function buildRegisteredTools(api, plugin) {
       },
     },
     {
-      name: 'claworld_list_owned_worlds',
-      label: 'Claworld List Owned Worlds',
-      description: 'Owner-focused governance tool. List the worlds owned by the current account before choosing one to manage.',
+      name: 'claworld_manage_world',
+      label: 'Claworld Manage World',
+      description: 'Unified owner-only world governance tool. List owned worlds, inspect one world, update worldContextText, or change world lifecycle to paused/closed/enabled.',
       metadata: buildToolMetadata({
         category: 'world_management',
         usageNotes: [
-          'Use when the user wants to inspect or pick from worlds they own.',
-          'This tool only returns owned worlds, not general directory worlds.',
-          'Pair this with claworld_manage_world for owner-only worldContext updates.',
+          'Use action=list to inspect the worlds owned by the current account.',
+          'Use action=get to inspect one owned world before changing it.',
+          'Use action=update_context to change worldContextText and optional displayName.',
+          'Use action=pause, action=close, or action=resume for owner-only lifecycle changes.',
         ],
         examples: [
           {
             title: 'List owned worlds',
             input: {
               accountId: 'claworld',
+              action: 'list',
             },
             outcome: 'Returns owner-managed worlds for the current account.',
           },
-        ],
-      }),
-      parameters: objectParam({
-        description: 'Minimal payload for listing worlds owned by the current account.',
-        required: ['accountId'],
-        properties: {
-          accountId: accountIdProperty,
-          includeDisabled: {
-            type: 'boolean',
-            description: 'Whether to include disabled or draft owned worlds.',
-          },
-        },
-        examples: [
-          {
-            accountId: 'claworld',
-          },
-        ],
-      }),
-      async execute(_toolCallId, params = {}) {
-        const context = await resolveToolContext(api, plugin, params);
-        const payload = await plugin.runtime.productShell.moderation.listOwnedWorlds({
-          ...context,
-          includeDisabled: params.includeDisabled !== false,
-        });
-        return buildToolResult(projectToolOwnedWorldsResponse(payload, { accountId: context.accountId }));
-      },
-    },
-    {
-      name: 'claworld_manage_world',
-      label: 'Claworld Manage World',
-      description: 'Owner-only world management tool. Update the canonical worldContextText for one owner-managed world, with optional displayName/enabled changes.',
-      metadata: buildToolMetadata({
-        category: 'world_management',
-        usageNotes: [
-          'Use only when the current agent owns the target world.',
-          'This is the minimal management tool on the current public surface.',
-          'Prefer updating worldContextText directly instead of editing legacy world schema fields.',
-        ],
-        examples: [
           {
             title: 'Update one owned world context',
             input: {
               accountId: 'claworld',
+              action: 'update_context',
               worldId: 'ugc-weekend-debate-club',
               worldContextText: '世界：Weekend Debate Club [ugc-weekend-debate-club]\n简介：A creator-managed world for short structured debates.\n互动规则：Debate one topic at a time and stay concise.',
             },
@@ -578,29 +592,39 @@ function buildRegisteredTools(api, plugin) {
         ],
       }),
       parameters: objectParam({
-        description: 'Minimal owner-only world management payload.',
-        required: ['accountId', 'worldId', 'worldContextText'],
+        description: 'Owner-only world governance payload. action=list replaces the old list_owned_worlds tool.',
+        required: ['accountId'],
         properties: {
           accountId: accountIdProperty,
+          action: stringParam({
+            description: 'Owner-only governance action. If omitted, the tool infers list/get/update_context from the provided fields.',
+            enumValues: MANAGE_WORLD_ACTIONS,
+            examples: ['list'],
+          }),
           worldId: worldIdProperty,
           worldContextText: stringParam({
-            description: 'Replacement canonical world context text for the owned world.',
+            description: 'Replacement canonical world context text for update_context.',
             minLength: 1,
             examples: ['世界：Weekend Debate Club [ugc-weekend-debate-club]\n简介：A creator-managed world for short structured debates.\n互动规则：Debate one topic at a time and stay concise.'],
           }),
           displayName: stringParam({
-            description: 'Optional new display name for the owned world.',
+            description: 'Optional new display name when action=update_context.',
             minLength: 1,
             examples: ['Weekend Debate Club'],
           }),
-          enabled: {
+          includeDisabled: {
             type: 'boolean',
-            description: 'Optional enabled flag for the owned world.',
+            description: 'Whether action=list should include paused, closed, or draft owned worlds.',
           },
         },
         examples: [
           {
             accountId: 'claworld',
+            action: 'list',
+          },
+          {
+            accountId: 'claworld',
+            action: 'update_context',
             worldId: 'ugc-weekend-debate-club',
             worldContextText: '世界：Weekend Debate Club [ugc-weekend-debate-club]\n简介：A creator-managed world for short structured debates.\n互动规则：Debate one topic at a time and stay concise.',
           },
@@ -608,18 +632,72 @@ function buildRegisteredTools(api, plugin) {
       }),
       async execute(_toolCallId, params = {}) {
         const context = await resolveToolContext(api, plugin, params);
-        const changes = {
-          worldContextText: params.worldContextText,
-          ...(params.displayName ? { displayName: params.displayName } : {}),
+        if (Object.prototype.hasOwnProperty.call(params, 'action')
+          && !normalizeManageWorldAction(params.action, null)) {
+          requireManageWorldField('action', 'action must be one of list, get, update_context, pause, close, or resume');
+        }
+        const action = inferManageWorldAction(params);
+        if (action === 'list') {
+          const payload = await plugin.runtime.productShell.moderation.listOwnedWorlds({
+            ...context,
+            includeDisabled: params.includeDisabled !== false,
+          });
+          return buildToolResult(projectToolManageWorldActionResponse(payload, {
+            accountId: context.accountId,
+            action,
+          }));
+        }
+
+        const worldId = normalizeText(params.worldId, null);
+        if (!worldId) requireManageWorldField('worldId');
+
+        if (action === 'get') {
+          const payload = await plugin.runtime.productShell.moderation.manageWorld({
+            ...context,
+            worldId,
+            mode: 'get',
+          });
+          return buildToolResult(projectToolManageWorldActionResponse(payload, {
+            accountId: context.accountId,
+            action,
+          }));
+        }
+
+        if (action === 'update_context') {
+          const worldContextText = normalizeText(params.worldContextText, null);
+          if (!worldContextText) requireManageWorldField('worldContextText');
+          const payload = await plugin.runtime.productShell.moderation.manageWorld({
+            ...context,
+            worldId,
+            mode: 'patch',
+            changes: {
+              worldContextText,
+              ...(normalizeText(params.displayName, null) ? { displayName: normalizeText(params.displayName, null) } : {}),
+            },
+          });
+          return buildToolResult(projectToolManageWorldActionResponse(payload, {
+            accountId: context.accountId,
+            action,
+          }));
+        }
+
+        const statusByAction = {
+          pause: 'paused',
+          close: 'closed',
+          resume: 'enabled',
         };
+        const status = statusByAction[action] || null;
         const payload = await plugin.runtime.productShell.moderation.manageWorld({
           ...context,
-          worldId: params.worldId,
+          worldId,
           mode: 'patch',
-          changes,
-          ...(Object.prototype.hasOwnProperty.call(params, 'enabled') ? { enabled: params.enabled === true } : {}),
+          status,
+          enabled: action === 'resume',
         });
-        return buildToolResult(projectToolManagedWorldResponse(payload, { accountId: context.accountId }));
+        return buildToolResult(projectToolManageWorldActionResponse(payload, {
+          accountId: context.accountId,
+          action,
+        }));
       },
     },
     {
@@ -782,6 +860,54 @@ function buildRegisteredTools(api, plugin) {
         return buildToolResult(projectToolChatRequestMutationResponse(payload, { accountId: context.accountId }));
       },
     },
+    {
+      name: 'claworld_reject_chat_request',
+      label: 'Claworld Reject Chat Request',
+      description: 'Canonical rejection tool for one inbound chat request. Use this when the current account explicitly declines the request instead of accepting it.',
+      metadata: buildToolMetadata({
+        category: 'chat_request',
+        usageNotes: [
+          'Use the chatRequestId returned by claworld_list_chat_requests.',
+          'Use only for inbound requests that the current account wants to reject.',
+        ],
+        examples: [
+          {
+            title: 'Reject one inbound request',
+            input: {
+              accountId: 'claworld',
+              chatRequestId: 'req_demo_1',
+            },
+            outcome: 'Marks the request rejected and returns the closed request projection.',
+          },
+        ],
+      }),
+      parameters: objectParam({
+        description: 'Reject one inbound chat request for the current account.',
+        required: ['accountId', 'chatRequestId'],
+        properties: {
+          accountId: accountIdProperty,
+          chatRequestId: stringParam({
+            description: 'Canonical chat request id returned by claworld_list_chat_requests.',
+            minLength: 1,
+            examples: ['req_demo_1'],
+          }),
+        },
+        examples: [
+          {
+            accountId: 'claworld',
+            chatRequestId: 'req_demo_1',
+          },
+        ],
+      }),
+      async execute(_toolCallId, params = {}) {
+        const context = await resolveToolContext(api, plugin, params);
+        const payload = await plugin.helpers.social.rejectChatRequest({
+          ...context,
+          chatRequestId: params.chatRequestId,
+        });
+        return buildToolResult(projectToolChatRequestMutationResponse(payload, { accountId: context.accountId }));
+      },
+    },
     {
       name: 'claworld_submit_feedback',
       label: 'Claworld Submit Feedback',

package/src/openclaw/plugin/relay-client.js

@@ -564,7 +564,7 @@ export class ClaworldRelayClient extends EventEmitter {
     config,
     agentId,
     credential = null,
-    clientVersion = 'claworld-plugin/0.2.7',
+    clientVersion = 'claworld-plugin/0.2.8',
     sessionTarget,
     fallbackTarget,
   } = {}) {
@@ -978,6 +978,7 @@ export class ClaworldRelayClient extends EventEmitter {
           stage: 'reply_fallback',
           deliveryId: envelope.deliveryId,
           sessionKey: envelope.sessionKey,
+          fallbackFrom: error?.code || error?.message || null,
         }),
       });
     }
@@ -1151,6 +1152,18 @@ export class ClaworldRelayClient extends EventEmitter {
     return result;
   }
 
+  async rejectChatRequest(requestId, { actorAgentId, ...options } = {}) {
+    return await this.requestJson(`/v1/chat-requests/${requestId}/reject`, {
+      method: 'POST',
+      headers: buildRuntimeAuthHeaders(this.runtimeConfig, { 'content-type': 'application/json' }),
+      body: JSON.stringify({ actorAgentId, ...options }),
+    }, {
+      code: 'relay_request_reject_failed',
+      message: 'failed to reject relay chat request',
+      publicMessage: 'failed to reject relay chat request',
+    });
+  }
+
   async deliverMessage({ fromAgentId, toAddress, payload = {}, conversation = {} } = {}) {
     return await this.requestJson('/v1/messages', {
       method: 'POST',

package/src/openclaw/runtime/tool-contracts.js

@@ -391,7 +391,7 @@ export function projectToolOwnedWorldsResponse(payload = {}, { accountId = null
     ? payload.items.map((world) => ({
       worldId: world.worldId,
       displayName: world.displayName,
-      summary: world.summary,
+      worldContextText: normalizeText(world.worldContextText, null),
       enabled: normalizeOptionalBoolean(world.enabled, null),
       status: normalizeText(world.status, null),
       worldRole: projectWorldRole(world.worldRole, null),

package/src/openclaw/runtime/tool-inventory.js

@@ -4,6 +4,7 @@ export const CLAWORLD_CHAT_REQUEST_TOOL_NAMES = Object.freeze([
   'claworld_request_chat',
   'claworld_chat_inbox',
   'claworld_accept_chat_request',
+  'claworld_reject_chat_request',
 ]);
 
 export const CLAWORLD_BOOTSTRAP_TOOL_NAMES = Object.freeze([
@@ -22,11 +23,11 @@ export const CLAWORLD_WORLD_TOOL_NAMES = Object.freeze([
 
 export const CLAWORLD_WORLD_ADMIN_PUBLIC_TOOL_NAMES = Object.freeze([
   'claworld_create_world',
-  'claworld_list_owned_worlds',
   'claworld_manage_world',
 ]);
 
 export const CLAWORLD_COMPATIBILITY_TOOL_NAMES = Object.freeze([
+  'claworld_list_owned_worlds',
   'claworld_prepare_world_join',
   'claworld_search_world',
 ]);

package/src/openclaw/runtime/world-moderation-helper.js

@@ -287,6 +287,7 @@ export async function manageModeratedWorld({
   mode = 'get',
   changes = null,
   enabled = null,
+  status = null,
   fetchImpl,
   logger = console,
 } = {}) {
@@ -340,6 +341,7 @@ export async function manageModeratedWorld({
       agentId: resolvedAgentId,
       ...(changes && typeof changes === 'object' ? { changes } : {}),
       ...(enabled == null ? {} : { enabled }),
+      ...(normalizeText(status, null) ? { status: normalizeText(status, null) } : {}),
     }),
   });
 

package/src/product-shell/worlds/world-admin-service.js

@@ -12,6 +12,36 @@ function normalizeBoolean(value, fallback = false) {
   return fallback;
 }
 
+const OWNER_WORLD_STATUSES = new Set(['draft', 'enabled', 'paused', 'closed', 'disabled']);
+
+function normalizeOwnerWorldStatus(value, fallback = null) {
+  const normalized = normalizeText(value, fallback);
+  return OWNER_WORLD_STATUSES.has(normalized) ? normalized : fallback;
+}
+
+function inferEnabledFromOwnerWorldStatus(status, fallback = null) {
+  const normalizedStatus = normalizeOwnerWorldStatus(status, null);
+  if (!normalizedStatus) return fallback;
+  return normalizedStatus === 'enabled';
+}
+
+function projectOwnerWorldMetaStatus(status, enabled) {
+  const normalizedStatus = normalizeOwnerWorldStatus(status, enabled === true ? 'enabled' : 'draft');
+  switch (normalizedStatus) {
+    case 'enabled':
+      return 'creator_enabled';
+    case 'paused':
+      return 'creator_paused';
+    case 'closed':
+      return 'creator_closed';
+    case 'disabled':
+      return 'creator_disabled';
+    case 'draft':
+    default:
+      return 'creator_draft';
+  }
+}
+
 function summarizeWorldContextText(worldContextText, fallback = null) {
   const normalized = normalizeText(worldContextText, null);
   if (!normalized) return fallback;
@@ -154,7 +184,7 @@ function buildWorldRecord({
   status = null,
   existingMetrics = null,
 } = {}) {
-  const resolvedStatus = status || (enabled ? 'enabled' : 'draft');
+  const resolvedStatus = normalizeOwnerWorldStatus(status, enabled ? 'enabled' : 'draft');
   const participantContextField = buildDefaultEntryProfileField();
   const resolvedWorldContextText = buildWorldContextText({
     worldId,
@@ -186,7 +216,7 @@ function buildWorldRecord({
     matching: buildMatchingStrategy(),
     conversationTemplate: buildConversationTemplate(null, null),
     meta: {
-      status: resolvedStatus === 'enabled' ? 'creator_enabled' : 'creator_draft',
+      status: projectOwnerWorldMetaStatus(resolvedStatus, enabled),
       persistence: 'store',
     },
     creatorAgentId,
@@ -314,6 +344,7 @@ export function createWorldAdminService({ worldService, worldAuthorizationServic
       displayName,
       worldContextText,
       enabled = false,
+      status = null,
     } = {}) {
       const storeBacked = assertStore();
       const resolvedOwnerAgentId = assertActorAgent(ownerAgentId || creatorAgentId);
@@ -330,6 +361,7 @@ export function createWorldAdminService({ worldService, worldAuthorizationServic
         summary: summarizeWorldContextText(resolvedWorldContextText, resolvedDisplayName),
         worldContextText: resolvedWorldContextText,
         enabled: normalizeBoolean(enabled, false),
+        status: normalizeOwnerWorldStatus(status, normalizeBoolean(enabled, false) ? 'enabled' : 'draft'),
       });
 
       const created = await storeBacked.createWorldConfig(worldRecord);
@@ -367,10 +399,14 @@ export function createWorldAdminService({ worldService, worldAuthorizationServic
         worldRole: authorization.worldRole,
       });
     },
-    async manageWorld({ actorAgentId, creatorAgentId, worldId, changes = null, enabled = null } = {}) {
+    async manageWorld({ actorAgentId, creatorAgentId, worldId, changes = null, enabled = null, status = null } = {}) {
       const storeBacked = assertStore();
       const resolvedActorAgentId = assertActorAgent(actorAgentId || creatorAgentId);
       const hasChanges = changes && typeof changes === 'object' && !Array.isArray(changes);
+      const normalizedStatus = normalizeOwnerWorldStatus(status, null);
+      const resolvedEnabled = normalizedStatus != null
+        ? inferEnabledFromOwnerWorldStatus(normalizedStatus, null)
+        : (enabled == null ? null : normalizeBoolean(enabled, false));
 
       const authorization = requireWorldOwner({
         worldId,
@@ -378,7 +414,7 @@ export function createWorldAdminService({ worldService, worldAuthorizationServic
       });
 
       const existingWorld = authorization.world;
-      if (!hasChanges && enabled == null) {
+      if (!hasChanges && resolvedEnabled == null && normalizedStatus == null) {
         return projectManagedWorld(storeBacked, existingWorld, {
           worldRole: authorization.worldRole,
         });
@@ -397,20 +433,24 @@ export function createWorldAdminService({ worldService, worldAuthorizationServic
           displayName: nextDisplayName,
           summary: summarizeWorldContextText(nextWorldContextText, nextDisplayName),
           worldContextText: nextWorldContextText,
-          enabled: enabled == null ? existingWorld.enabled === true : normalizeBoolean(enabled, false),
-          status: enabled == null
-            ? existingWorld.status
-            : (normalizeBoolean(enabled, false) ? 'enabled' : 'disabled'),
+          enabled: resolvedEnabled == null ? existingWorld.enabled === true : resolvedEnabled,
+          status: normalizedStatus || (
+            resolvedEnabled == null
+              ? existingWorld.status
+              : (resolvedEnabled ? 'enabled' : 'disabled')
+          ),
           existingMetrics: existingWorld.metrics || null,
         });
-      } else if (enabled != null) {
+      } else if (resolvedEnabled != null || normalizedStatus != null) {
+        const nextEnabled = resolvedEnabled == null ? existingWorld.enabled === true : resolvedEnabled;
+        const nextStatus = normalizedStatus || (nextEnabled ? 'enabled' : 'disabled');
         nextRecord = {
           ...existingWorld,
-          enabled: normalizeBoolean(enabled, false),
-          status: normalizeBoolean(enabled, false) ? 'enabled' : 'disabled',
+          enabled: nextEnabled,
+          status: nextStatus,
           meta: {
             ...(existingWorld.meta || {}),
-            status: normalizeBoolean(enabled, false) ? 'creator_enabled' : 'creator_disabled',
+            status: projectOwnerWorldMetaStatus(nextStatus, nextEnabled),
           },
         };
       }

package/src/product-shell/worlds/world-routes.js

@@ -393,6 +393,7 @@ export function registerWorldRoutes(
         worldId: req.params.worldId,
         changes: req.body?.changes || null,
         enabled: Object.prototype.hasOwnProperty.call(req.body || {}, 'enabled') ? req.body.enabled : null,
+        status: req.body?.status || null,
       });
       res.json(result);
     } catch (error) {