@xfxstudio/claworld 0.2.6 → 0.2.8

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

@@ -15,6 +15,7 @@ import {
 const DUPLICATE_CONNECTION_CLOSE_CODE = 4001;
 const STALE_CONNECTION_CLOSE_CODE = 4002;
 const TERMINAL_CLOSE_REASONS = new Set(['duplicate_connection_replaced', 'stale_connection']);
+const DEFAULT_REPLY_ACK_TIMEOUT_MS = 5000;
 
 function normalizeRelayWebSocketUrl(serverUrl) {
   const parsed = new URL(serverUrl);
@@ -49,6 +50,90 @@ function buildInboundEnvelope(message = {}) {
   };
 }
 
+function normalizeOptionalText(value) {
+  if (value == null) return null;
+  const normalized = String(value).trim();
+  return normalized || null;
+}
+
+function buildReplyAckTimeoutError({ deliveryId, timeoutMs, context = {} } = {}) {
+  return createRuntimeBoundaryError({
+    code: 'relay_reply_ack_timeout',
+    category: 'transport',
+    status: 504,
+    message: `timed out waiting for relay reply acknowledgement for ${deliveryId || 'unknown-delivery'} after ${timeoutMs}ms`,
+    publicMessage: 'relay reply acknowledgement timed out',
+    recoverable: true,
+    context,
+  });
+}
+
+function buildReplyFallbackError({
+  deliveryId,
+  status,
+  body,
+  context = {},
+} = {}) {
+  return createRuntimeBoundaryError({
+    code: normalizeOptionalText(body?.code) || normalizeOptionalText(body?.error) || 'relay_reply_fallback_failed',
+    category: status >= 500 ? 'runtime' : 'transport',
+    status: Number.isInteger(status) ? status : 502,
+    message: normalizeOptionalText(body?.message) || normalizeOptionalText(body?.reason) || 'relay reply fallback failed',
+    publicMessage: 'relay reply fallback failed',
+    recoverable: status >= 500,
+    context: {
+      deliveryId: normalizeOptionalText(deliveryId),
+      ...context,
+    },
+  });
+}
+
+function buildKeepSilentAckTimeoutError({ deliveryId, timeoutMs, context = {} } = {}) {
+  return createRuntimeBoundaryError({
+    code: 'relay_kept_silent_ack_timeout',
+    category: 'transport',
+    status: 504,
+    message: `timed out waiting for relay kept_silent acknowledgement for ${deliveryId || 'unknown-delivery'} after ${timeoutMs}ms`,
+    publicMessage: 'relay kept_silent acknowledgement timed out',
+    recoverable: true,
+    context,
+  });
+}
+
+function buildKeepSilentFallbackError({
+  deliveryId,
+  status,
+  body,
+  context = {},
+} = {}) {
+  return createRuntimeBoundaryError({
+    code: normalizeOptionalText(body?.code) || normalizeOptionalText(body?.error) || 'relay_kept_silent_fallback_failed',
+    category: status >= 500 ? 'runtime' : 'transport',
+    status: Number.isInteger(status) ? status : 502,
+    message: normalizeOptionalText(body?.message) || normalizeOptionalText(body?.reason) || 'relay kept_silent fallback failed',
+    publicMessage: 'relay kept_silent fallback failed',
+    recoverable: status >= 500,
+    context: {
+      deliveryId: normalizeOptionalText(deliveryId),
+      ...context,
+    },
+  });
+}
+
+function isReplyAlreadyApplied(result = null, deliveryId = null) {
+  if (!result || result.status !== 409) return false;
+  if (normalizeOptionalText(result.body?.reason) !== 'delivery_not_replyable') return false;
+  if (normalizeOptionalText(result.body?.delivery?.deliveryId) !== normalizeOptionalText(deliveryId)) return false;
+  return normalizeOptionalText(result.body?.delivery?.status) === 'replied';
+}
+
+function isDeliveryKeptSilentAlreadyApplied(result = null, deliveryId = null) {
+  if (!result || result.status !== 409) return false;
+  if (normalizeOptionalText(result.body?.reason) !== 'delivery_not_replyable') return false;
+  if (normalizeOptionalText(result.body?.delivery?.deliveryId) !== normalizeOptionalText(deliveryId)) return false;
+  return normalizeOptionalText(result.body?.delivery?.status) === 'kept_silent';
+}
+
 export class ClaworldRelayClient extends EventEmitter {
   constructor({
     logger = console,
@@ -597,6 +682,420 @@ export class ClaworldRelayClient extends EventEmitter {
     });
   }
 
+  sendKeepSilent({ deliveryId, sessionKey, reason = null, source = 'openclaw-autochain' } = {}) {
+    const normalizedDeliveryId = normalizeOptionalText(deliveryId);
+    if (!normalizedDeliveryId) {
+      throw createRuntimeBoundaryError({
+        code: 'relay_delivery_id_required',
+        category: 'input',
+        status: 400,
+        message: 'deliveryId is required to mark relay delivery kept_silent',
+        publicMessage: 'deliveryId is required',
+        recoverable: true,
+      });
+    }
+    const envelope = {
+      deliveryId: normalizedDeliveryId,
+      sessionKey: normalizeOptionalText(sessionKey) || null,
+      reason: normalizeOptionalText(reason) || 'no_renderable_reply',
+      source: normalizeOptionalText(source) || 'openclaw-autochain',
+    };
+    this.send({
+      type: 'kept_silent',
+      deliveryId: envelope.deliveryId,
+      sessionKey: envelope.sessionKey,
+      payload: {
+        reason: envelope.reason,
+        source: envelope.source,
+      },
+    });
+    return envelope;
+  }
+
+  waitForReplyAck({ deliveryId, timeoutMs = DEFAULT_REPLY_ACK_TIMEOUT_MS } = {}) {
+    const normalizedDeliveryId = normalizeOptionalText(deliveryId);
+    if (!normalizedDeliveryId) {
+      return Promise.reject(createRuntimeBoundaryError({
+        code: 'relay_delivery_id_required',
+        category: 'input',
+        status: 400,
+        message: 'deliveryId is required to wait for relay reply acknowledgement',
+        publicMessage: 'deliveryId is required',
+        recoverable: true,
+      }));
+    }
+
+    return new Promise((resolve, reject) => {
+      let settled = false;
+      let timeout = null;
+
+      const cleanup = () => {
+        if (timeout) clearTimeout(timeout);
+        this.off('reply.accepted', onReplyAccepted);
+        this.off('disconnect', onDisconnect);
+        this.off('close', onDisconnect);
+      };
+
+      const settleResolve = (value) => {
+        if (settled) return;
+        settled = true;
+        cleanup();
+        resolve(value);
+      };
+
+      const settleReject = (error) => {
+        if (settled) return;
+        settled = true;
+        cleanup();
+        reject(error);
+      };
+
+      const onReplyAccepted = (message = {}) => {
+        const repliedDeliveryId = normalizeOptionalText(message?.data?.repliedDeliveryId);
+        if (repliedDeliveryId !== normalizedDeliveryId) return;
+        settleResolve(message);
+      };
+
+      const onDisconnect = (info = {}) => {
+        settleReject(createRuntimeBoundaryError({
+          code: 'relay_reply_ack_disconnected',
+          category: 'transport',
+          status: 502,
+          message: `relay websocket closed before reply acknowledgement for ${normalizedDeliveryId}`,
+          publicMessage: 'relay websocket closed before reply acknowledgement',
+          recoverable: true,
+          context: this.buildBoundaryContext({
+            stage: 'reply_ack_wait',
+            deliveryId: normalizedDeliveryId,
+            closeCode: info?.code ?? null,
+            closeReason: info?.reason || null,
+          }),
+        }));
+      };
+
+      this.on('reply.accepted', onReplyAccepted);
+      this.on('disconnect', onDisconnect);
+      this.on('close', onDisconnect);
+
+      timeout = setTimeout(() => {
+        settleReject(buildReplyAckTimeoutError({
+          deliveryId: normalizedDeliveryId,
+          timeoutMs,
+          context: this.buildBoundaryContext({
+            stage: 'reply_ack_wait',
+            deliveryId: normalizedDeliveryId,
+          }),
+        }));
+      }, timeoutMs);
+      if (typeof timeout.unref === 'function') timeout.unref();
+    });
+  }
+
+  waitForKeepSilentAck({ deliveryId, timeoutMs = DEFAULT_REPLY_ACK_TIMEOUT_MS } = {}) {
+    const normalizedDeliveryId = normalizeOptionalText(deliveryId);
+    if (!normalizedDeliveryId) {
+      return Promise.reject(createRuntimeBoundaryError({
+        code: 'relay_delivery_id_required',
+        category: 'input',
+        status: 400,
+        message: 'deliveryId is required to wait for relay kept_silent acknowledgement',
+        publicMessage: 'deliveryId is required',
+        recoverable: true,
+      }));
+    }
+
+    return new Promise((resolve, reject) => {
+      let settled = false;
+      let timeout = null;
+
+      const cleanup = () => {
+        if (timeout) clearTimeout(timeout);
+        this.off('kept_silent.accepted', onKeptSilentAccepted);
+        this.off('disconnect', onDisconnect);
+        this.off('close', onDisconnect);
+      };
+
+      const settleResolve = (value) => {
+        if (settled) return;
+        settled = true;
+        cleanup();
+        resolve(value);
+      };
+
+      const settleReject = (error) => {
+        if (settled) return;
+        settled = true;
+        cleanup();
+        reject(error);
+      };
+
+      const onKeptSilentAccepted = (message = {}) => {
+        const keptSilentDeliveryId = normalizeOptionalText(message?.data?.keptSilentDeliveryId);
+        if (keptSilentDeliveryId !== normalizedDeliveryId) return;
+        settleResolve(message);
+      };
+
+      const onDisconnect = (info = {}) => {
+        settleReject(createRuntimeBoundaryError({
+          code: 'relay_kept_silent_ack_disconnected',
+          category: 'transport',
+          status: 502,
+          message: `relay websocket closed before kept_silent acknowledgement for ${normalizedDeliveryId}`,
+          publicMessage: 'relay websocket closed before kept_silent acknowledgement',
+          recoverable: true,
+          context: this.buildBoundaryContext({
+            stage: 'kept_silent_ack_wait',
+            deliveryId: normalizedDeliveryId,
+            closeCode: info?.code ?? null,
+            closeReason: info?.reason || null,
+          }),
+        }));
+      };
+
+      this.on('kept_silent.accepted', onKeptSilentAccepted);
+      this.on('disconnect', onDisconnect);
+      this.on('close', onDisconnect);
+
+      timeout = setTimeout(() => {
+        settleReject(buildKeepSilentAckTimeoutError({
+          deliveryId: normalizedDeliveryId,
+          timeoutMs,
+          context: this.buildBoundaryContext({
+            stage: 'kept_silent_ack_wait',
+            deliveryId: normalizedDeliveryId,
+          }),
+        }));
+      }, timeoutMs);
+      if (typeof timeout.unref === 'function') timeout.unref();
+    });
+  }
+
+  async replyToDeliveryHttp({ deliveryId, replyText, source = 'subagent' } = {}) {
+    const envelope = this.outbound.createReplyEnvelope({
+      deliveryId,
+      sessionKey: null,
+      replyText,
+      source,
+    });
+    const result = await this.requestJson(`/v1/deliveries/${encodeURIComponent(envelope.deliveryId)}/reply`, {
+      method: 'POST',
+      headers: buildRuntimeAuthHeaders(this.runtimeConfig, { 'content-type': 'application/json' }),
+      body: JSON.stringify({
+        fromAgentId: this.boundAgentId,
+        payload: {
+          ...envelope.payload,
+        },
+      }),
+    }, {
+      code: 'relay_reply_fallback_failed',
+      message: 'failed to submit relay reply fallback',
+      publicMessage: 'failed to submit relay reply fallback',
+    });
+    return {
+      ...result,
+      envelope,
+    };
+  }
+
+  async sendReplyAndWaitForAck({
+    deliveryId,
+    sessionKey,
+    replyText,
+    source = 'subagent',
+    timeoutMs = DEFAULT_REPLY_ACK_TIMEOUT_MS,
+    httpFallback = true,
+  } = {}) {
+    const envelope = this.sendReply({
+      deliveryId,
+      sessionKey,
+      replyText,
+      source,
+    });
+
+    try {
+      const ack = await this.waitForReplyAck({
+        deliveryId: envelope.deliveryId,
+        timeoutMs,
+      });
+      return {
+        ok: true,
+        envelope,
+        ack,
+        transport: 'websocket',
+        fallbackUsed: false,
+      };
+    } catch (error) {
+      if (!httpFallback) throw error;
+
+      this.logger.warn?.('[claworld:relay-client] reply websocket acknowledgement failed; attempting HTTP fallback', {
+        accountId: this.runtimeConfig?.accountId || null,
+        agentId: this.boundAgentId,
+        deliveryId: envelope.deliveryId,
+        sessionKey: envelope.sessionKey,
+        error: error?.message || String(error),
+      });
+
+      const fallbackResult = await this.replyToDeliveryHttp({
+        deliveryId: envelope.deliveryId,
+        replyText,
+        source,
+      });
+
+      if (fallbackResult.status >= 200 && fallbackResult.status < 300) {
+        return {
+          ok: true,
+          envelope,
+          ack: {
+            event: 'reply.accepted',
+            data: fallbackResult.body,
+          },
+          transport: 'http',
+          fallbackUsed: true,
+        };
+      }
+
+      if (isReplyAlreadyApplied(fallbackResult, envelope.deliveryId)) {
+        return {
+          ok: true,
+          envelope,
+          ack: {
+            event: 'reply.accepted',
+            data: {
+              ...(fallbackResult.body && typeof fallbackResult.body === 'object' ? fallbackResult.body : {}),
+              repliedDeliveryId: envelope.deliveryId,
+            },
+          },
+          transport: 'http-already-applied',
+          fallbackUsed: true,
+        };
+      }
+
+      throw buildReplyFallbackError({
+        deliveryId: envelope.deliveryId,
+        status: fallbackResult.status,
+        body: fallbackResult.body,
+        context: this.buildBoundaryContext({
+          stage: 'reply_fallback',
+          deliveryId: envelope.deliveryId,
+          sessionKey: envelope.sessionKey,
+          fallbackFrom: error?.code || error?.message || null,
+        }),
+      });
+    }
+  }
+
+  async keepDeliverySilentHttp({ deliveryId, reason = null, source = 'openclaw-autochain' } = {}) {
+    const normalizedDeliveryId = normalizeOptionalText(deliveryId);
+    const result = await this.requestJson(`/v1/deliveries/${encodeURIComponent(normalizedDeliveryId)}/kept-silent`, {
+      method: 'POST',
+      headers: buildRuntimeAuthHeaders(this.runtimeConfig, { 'content-type': 'application/json' }),
+      body: JSON.stringify({
+        fromAgentId: this.boundAgentId,
+        reason: normalizeOptionalText(reason) || 'no_renderable_reply',
+        source: normalizeOptionalText(source) || 'openclaw-autochain',
+      }),
+    }, {
+      code: 'relay_kept_silent_fallback_failed',
+      message: 'failed to submit relay kept_silent fallback',
+      publicMessage: 'failed to submit relay kept_silent fallback',
+    });
+    return {
+      ...result,
+      envelope: {
+        deliveryId: normalizedDeliveryId,
+        reason: normalizeOptionalText(reason) || 'no_renderable_reply',
+        source: normalizeOptionalText(source) || 'openclaw-autochain',
+      },
+    };
+  }
+
+  async sendKeepSilentAndWaitForAck({
+    deliveryId,
+    sessionKey,
+    reason = null,
+    source = 'openclaw-autochain',
+    timeoutMs = DEFAULT_REPLY_ACK_TIMEOUT_MS,
+    httpFallback = true,
+  } = {}) {
+    const envelope = this.sendKeepSilent({
+      deliveryId,
+      sessionKey,
+      reason,
+      source,
+    });
+
+    try {
+      const ack = await this.waitForKeepSilentAck({
+        deliveryId: envelope.deliveryId,
+        timeoutMs,
+      });
+      return {
+        ok: true,
+        envelope,
+        ack,
+        transport: 'websocket',
+        fallbackUsed: false,
+      };
+    } catch (error) {
+      if (!httpFallback) throw error;
+
+      this.logger.warn?.('[claworld:relay-client] kept_silent websocket acknowledgement failed; attempting HTTP fallback', {
+        accountId: this.runtimeConfig?.accountId || null,
+        agentId: this.boundAgentId,
+        deliveryId: envelope.deliveryId,
+        sessionKey: envelope.sessionKey,
+        error: error?.message || String(error),
+      });
+
+      const fallbackResult = await this.keepDeliverySilentHttp({
+        deliveryId: envelope.deliveryId,
+        reason: envelope.reason,
+        source: envelope.source,
+      });
+
+      if (fallbackResult.status >= 200 && fallbackResult.status < 300) {
+        return {
+          ok: true,
+          envelope,
+          ack: {
+            event: 'kept_silent.accepted',
+            data: fallbackResult.body,
+          },
+          transport: 'http',
+          fallbackUsed: true,
+        };
+      }
+
+      if (isDeliveryKeptSilentAlreadyApplied(fallbackResult, envelope.deliveryId)) {
+        return {
+          ok: true,
+          envelope,
+          ack: {
+            event: 'kept_silent.accepted',
+            data: {
+              ...(fallbackResult.body && typeof fallbackResult.body === 'object' ? fallbackResult.body : {}),
+              keptSilentDeliveryId: envelope.deliveryId,
+            },
+          },
+          transport: 'http-already-applied',
+          fallbackUsed: true,
+        };
+      }
+
+      throw buildKeepSilentFallbackError({
+        deliveryId: envelope.deliveryId,
+        status: fallbackResult.status,
+        body: fallbackResult.body,
+        context: this.buildBoundaryContext({
+          stage: 'kept_silent_fallback',
+          deliveryId: envelope.deliveryId,
+          sessionKey: envelope.sessionKey,
+          fallbackFrom: error?.code || error?.message || null,
+        }),
+      });
+    }
+  }
+
   async createChatRequest({ fromAgentId, toAddress, requestContext = {} } = {}) {
     const target = await this.requestJson(`/v1/agents/resolve?address=${encodeURIComponent(toAddress)}`, {
       method: 'GET',
@@ -650,6 +1149,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/demo-session-bootstrap.js

@@ -23,8 +23,7 @@ export function createDemoSessionBootstrap() {
           'load demo world',
           'create manual session',
           'inject opening system message',
-          'wait for dual raise or manual stop',
-          'build canonical result',
+          'wait for conversation closure or manual stop',
         ],
         status: 'planned',
       };

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_list_chat_requests',
   '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

@@ -207,12 +207,11 @@ export async function createModeratedWorld({
   const baseUrl = normalizeRelayHttpBaseUrl(resolvedRuntimeConfig.serverUrl);
   const created = await fetchJson(fetchImpl, `${baseUrl}/v1/worlds`, {
     method: 'POST',
-    headers: {
+    headers: buildRuntimeAuthHeaders(resolvedRuntimeConfig, {
       accept: 'application/json',
       'content-type': 'application/json',
       ...(resolvedRuntimeConfig.apiKey ? { 'x-api-key': resolvedRuntimeConfig.apiKey } : {}),
-      ...(resolvedRuntimeConfig.relay?.credentialToken ? { 'x-relay-token': resolvedRuntimeConfig.relay.credentialToken } : {}),
-    },
+    }),
     body: JSON.stringify({
       agentId: resolvedAgentId,
       displayName,
@@ -259,11 +258,10 @@ export async function fetchOwnedWorlds({
   requestUrl.searchParams.set('agentId', resolvedAgentId);
   requestUrl.searchParams.set('includeDisabled', includeDisabled ? 'true' : 'false');
   const result = await fetchJson(fetchImpl, requestUrl.toString(), {
-    headers: {
+    headers: buildRuntimeAuthHeaders(resolvedRuntimeConfig, {
       accept: 'application/json',
       ...(resolvedRuntimeConfig.apiKey ? { 'x-api-key': resolvedRuntimeConfig.apiKey } : {}),
-      ...(resolvedRuntimeConfig.relay?.credentialToken ? { 'x-relay-token': resolvedRuntimeConfig.relay.credentialToken } : {}),
-    },
+    }),
   });
 
   if (!result.ok) {
@@ -289,6 +287,7 @@ export async function manageModeratedWorld({
   mode = 'get',
   changes = null,
   enabled = null,
+  status = null,
   fetchImpl,
   logger = console,
 } = {}) {
@@ -312,11 +311,10 @@ export async function manageModeratedWorld({
     const requestUrl = new URL(`${baseUrl}/v1/moderation/worlds/${encodeURIComponent(resolvedWorldId)}`);
     requestUrl.searchParams.set('agentId', resolvedAgentId);
     const result = await fetchJson(fetchImpl, requestUrl.toString(), {
-      headers: {
+      headers: buildRuntimeAuthHeaders(resolvedRuntimeConfig, {
         accept: 'application/json',
         ...(resolvedRuntimeConfig.apiKey ? { 'x-api-key': resolvedRuntimeConfig.apiKey } : {}),
-        ...(resolvedRuntimeConfig.relay?.credentialToken ? { 'x-relay-token': resolvedRuntimeConfig.relay.credentialToken } : {}),
-      },
+      }),
     });
 
     if (!result.ok) {
@@ -334,16 +332,16 @@ export async function manageModeratedWorld({
 
   const result = await fetchJson(fetchImpl, `${baseUrl}/v1/moderation/worlds/${encodeURIComponent(resolvedWorldId)}`, {
     method: 'PATCH',
-    headers: {
+    headers: buildRuntimeAuthHeaders(resolvedRuntimeConfig, {
       accept: 'application/json',
       'content-type': 'application/json',
       ...(resolvedRuntimeConfig.apiKey ? { 'x-api-key': resolvedRuntimeConfig.apiKey } : {}),
-      ...(resolvedRuntimeConfig.relay?.credentialToken ? { 'x-relay-token': resolvedRuntimeConfig.relay.credentialToken } : {}),
-    },
+    }),
     body: JSON.stringify({
       agentId: resolvedAgentId,
       ...(changes && typeof changes === 'object' ? { changes } : {}),
       ...(enabled == null ? {} : { enabled }),
+      ...(normalizeText(status, null) ? { status: normalizeText(status, null) } : {}),
     }),
   });
 

package/src/product-shell/catalog/default-world-catalog.js

@@ -9,7 +9,7 @@ export const DEFAULT_WORLD_MANIFESTS = Object.freeze([
     lifecycle: 'prototype',
     tags: ['dating', 'matching', 'a2a'],
     worldContextText:
-      '世界：Dating Demo World [dating-demo-world]\n简介：A lightweight social world for proving world-scoped join, review, and chat request flow.\n互动规则：Clarify fit quickly, stay respectful, and stop once next steps are clear.\n禁止事项：Do not pressure, harass, manipulate, or ask for unsafe personal details.\n结果要求：Rate the interaction from 1 to 10 based on fit, clarity, and respect.',
+      '世界：Dating Demo World [dating-demo-world]\n简介：A lightweight social world for proving world-scoped join, review, and chat request flow.\n互动规则：Clarify fit quickly, stay respectful, and stop once next steps are clear.\n禁止事项：Do not pressure, harass, manipulate, or ask for unsafe personal details.',
   },
   {
     worldId: 'skill-handoff-world',
@@ -21,7 +21,7 @@ export const DEFAULT_WORLD_MANIFESTS = Object.freeze([
     lifecycle: 'prototype',
     tags: ['skills', 'services', 'matching'],
     worldContextText:
-      '世界：Skill Handoff World [skill-handoff-world]\n简介：A service marketplace world where agents screen delivery fit before moving to direct human contact.\n互动规则：Clarify scope, constraints, and whether a handoff is justified.\n禁止事项：Do not misrepresent capabilities or hide delivery blockers.\n结果要求：Rate the exchange from 1 to 10 based on scope clarity and handoff confidence.',
+      '世界：Skill Handoff World [skill-handoff-world]\n简介：A service marketplace world where agents screen delivery fit before moving to direct human contact.\n互动规则：Clarify scope, constraints, and whether a handoff is justified.\n禁止事项：Do not misrepresent capabilities or hide delivery blockers.',
   },
   {
     worldId: 'job-match-world',
@@ -33,6 +33,6 @@ export const DEFAULT_WORLD_MANIFESTS = Object.freeze([
     lifecycle: 'prototype',
     tags: ['jobs', 'recruiting', 'screening'],
     worldContextText:
-      '世界：Job Match World [job-match-world]\n简介：A recruiting world for agent-assisted screening before direct human contact.\n互动规则：Focus on fit, constraints, and whether a next step is justified.\n禁止事项：Do not fabricate experience, compensation, or hiring authority.\n结果要求：Rate the interaction from 1 to 10 based on fit, clarity, and follow-up likelihood.',
+      '世界：Job Match World [job-match-world]\n简介：A recruiting world for agent-assisted screening before direct human contact.\n互动规则：Focus on fit, constraints, and whether a next step is justified.\n禁止事项：Do not fabricate experience, compensation, or hiring authority.',
   },
 ]);