@xfxstudio/claworld 2026.5.10-testing.1 → 2026.5.14-testing.1

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

@@ -595,6 +595,34 @@ function projectToolAccountProfile(identityPayload = null) {
   return normalizeText(identityPayload?.profile, null);
 }
 
+function projectToolAccountProfileState(identityPayload = null) {
+  const profilePayload = normalizeObject(identityPayload?.accountProfile, null);
+  const profile = normalizeText(profilePayload?.profile, projectToolAccountProfile(identityPayload));
+  const ready = profilePayload
+    ? profilePayload.ready === true
+    : Boolean(profile);
+  return {
+    status: normalizeText(profilePayload?.status, ready ? 'ready' : 'pending'),
+    ready,
+    profile,
+    reason: normalizeText(profilePayload?.reason, ready ? null : 'account_profile_missing'),
+    requiredAction: normalizeText(profilePayload?.requiredAction, ready ? null : 'update_agent_profile'),
+    nextAction: normalizeText(profilePayload?.nextAction, ready ? null : 'update_agent_profile'),
+    nextTool: normalizeText(profilePayload?.nextTool, ready ? null : 'claworld_manage_account'),
+    missingFields: Array.isArray(profilePayload?.missingFields)
+      ? profilePayload.missingFields
+      : (ready
+          ? []
+          : [
+              {
+                fieldId: 'profile',
+                label: 'Account Profile',
+                description: 'A non-empty global Claworld account profile used when other agents need to know who you are.',
+              },
+            ]),
+  };
+}
+
 function projectToolChatRequestApprovalPolicy(payload = null) {
   const policy = normalizeObject(payload, null);
   if (!policy) return null;
@@ -652,7 +680,10 @@ export function projectToolAccountViewResponse({
   pairingPayload = null,
   identityPayload = null,
 } = {}) {
+  const publicIdentityState = projectToolAccountIdentityFields(identityPayload);
+  const accountProfile = projectToolAccountProfileState(identityPayload);
   const identityReady = identityPayload?.ready === true;
+  const accountProfileReady = accountProfile.ready === true;
   const activationReady = pairingPayload?.status === 'paired';
   const bindingReady = typeof pairingPayload?.bindingReady === 'boolean'
     ? pairingPayload.bindingReady
@@ -663,7 +694,30 @@ export function projectToolAccountViewResponse({
       ? (bindingReady ? 'bound' : 'identity_unresolved')
       : 'unactivated',
   );
-  const ready = activationReady && identityReady;
+  const ready = activationReady && identityReady && accountProfileReady;
+  const blockedAction = !identityReady
+    ? {
+        requiredAction: publicIdentityState.requiredAction,
+        nextAction: publicIdentityState.nextAction,
+        nextTool: publicIdentityState.nextTool,
+        missingFields: publicIdentityState.missingFields,
+        reason: 'public_identity_incomplete',
+      }
+    : !accountProfileReady
+      ? {
+          requiredAction: accountProfile.requiredAction,
+          nextAction: accountProfile.nextAction,
+          nextTool: accountProfile.nextTool,
+          missingFields: accountProfile.missingFields,
+          reason: accountProfile.reason,
+        }
+      : {
+          requiredAction: null,
+          nextAction: null,
+          nextTool: null,
+          missingFields: [],
+          reason: null,
+        };
   const relayResolved = pairingPayload?.relayAgent?.resolved ?? null;
   const relayOnline = pairingPayload?.relayAgent?.online ?? null;
   const resolvedShareCard = identityPayload && Object.prototype.hasOwnProperty.call(identityPayload, 'shareCard')
@@ -674,10 +728,12 @@ export function projectToolAccountViewResponse({
     status: ready ? 'ready' : 'pending',
     ready,
     readiness: pairingPayload?.status === 'paired'
-      ? (identityReady ? 'paired_and_ready' : 'paired_but_identity_pending')
+      ? (identityReady
+          ? (accountProfileReady ? 'paired_and_ready' : 'paired_but_account_profile_incomplete')
+          : 'paired_but_identity_pending')
       : 'installed_unactivated',
     accountId: normalizeText(pairingPayload?.runtimeConfig?.accountId, normalizeText(accountId, null)),
-    reason: normalizeText(pairingPayload?.reason, null),
+    reason: normalizeText(pairingPayload?.reason, blockedAction.reason),
     bindingSource: normalizeText(pairingPayload?.bindingSource, null),
     activation: {
       status: activationReady ? 'ready' : 'pending',
@@ -687,6 +743,7 @@ export function projectToolAccountViewResponse({
       bindingReady,
       bindingStatus,
       publicIdentityReady: identityReady,
+      accountProfileReady,
       relayPresenceResolved: relayResolved,
       relayOnline,
     },
@@ -702,8 +759,13 @@ export function projectToolAccountViewResponse({
       resolved: relayResolved,
       bindingStatus,
     },
-    profile: projectToolAccountProfile(identityPayload),
-    ...projectToolAccountIdentityFields(identityPayload),
+    profile: accountProfile.profile,
+    ...publicIdentityState,
+    accountProfile,
+    requiredAction: blockedAction.requiredAction,
+    nextAction: blockedAction.nextAction,
+    nextTool: blockedAction.nextTool,
+    missingFields: blockedAction.missingFields,
     pluginVersionStatus: projectToolPluginVersionStatus(identityPayload?.pluginVersionStatus),
     chatRequestApprovalPolicy: projectToolChatRequestApprovalPolicy(identityPayload?.chatRequestApprovalPolicy),
     ...(resolvedShareCard !== undefined ? { shareCard: resolvedShareCard } : {}),
@@ -717,19 +779,55 @@ export function projectToolAccountMutationResponse({
   shareCard = undefined,
   runtimeActivation = null,
 } = {}) {
+  const publicIdentityState = projectToolAccountIdentityFields(identityPayload);
+  const accountProfile = projectToolAccountProfileState(identityPayload);
   const resolvedShareCard = shareCard !== undefined
     ? shareCard
     : (identityPayload && Object.prototype.hasOwnProperty.call(identityPayload, 'shareCard')
         ? projectToolShareCard(identityPayload.shareCard)
         : undefined);
-  const ready = identityPayload?.ready === true;
+  const identityReady = identityPayload?.ready === true;
+  const accountProfileReady = accountProfile.ready === true;
+  const ready = identityReady && accountProfileReady;
+  const blockedAction = !identityReady
+    ? {
+        requiredAction: publicIdentityState.requiredAction,
+        nextAction: publicIdentityState.nextAction,
+        nextTool: publicIdentityState.nextTool,
+        missingFields: publicIdentityState.missingFields,
+        reason: 'public_identity_incomplete',
+      }
+    : !accountProfileReady
+      ? {
+          requiredAction: accountProfile.requiredAction,
+          nextAction: accountProfile.nextAction,
+          nextTool: accountProfile.nextTool,
+          missingFields: accountProfile.missingFields,
+          reason: accountProfile.reason,
+        }
+      : {
+          requiredAction: null,
+          nextAction: null,
+          nextTool: null,
+          missingFields: [],
+          reason: null,
+        };
   return {
     action,
     status: ready ? 'ready' : 'pending',
     ready,
+    readiness: identityReady
+      ? (accountProfileReady ? 'ready' : 'account_profile_incomplete')
+      : 'public_identity_incomplete',
     accountId: normalizeText(accountId, null),
-    profile: projectToolAccountProfile(identityPayload),
-    ...projectToolAccountIdentityFields(identityPayload),
+    profile: accountProfile.profile,
+    ...publicIdentityState,
+    accountProfile,
+    requiredAction: blockedAction.requiredAction,
+    nextAction: blockedAction.nextAction,
+    nextTool: blockedAction.nextTool,
+    missingFields: blockedAction.missingFields,
+    reason: blockedAction.reason,
     pluginVersionStatus: projectToolPluginVersionStatus(identityPayload?.pluginVersionStatus),
     chatRequestApprovalPolicy: projectToolChatRequestApprovalPolicy(identityPayload?.chatRequestApprovalPolicy),
     ...(resolvedShareCard !== undefined ? { shareCard: resolvedShareCard } : {}),

package/src/openclaw/plugin/register.js

@@ -18,6 +18,7 @@ import {
   buildClaworldToolMaintenanceEvent,
   ensureClaworldWorkingMemory,
   resolveClaworldBootstrapTarget,
+  updateClaworldSessionDirectory,
 } from '../runtime/working-memory.js';
 import { resolveOpenClawWorkspaceRoot } from '../runtime/workspace-resolver.js';
 import { setClaworldRuntime } from './runtime.js';
@@ -2224,13 +2225,43 @@ export function registerClaworldPluginFull(api, plugin) {
     });
 
     api.on('before_tool_call', async (event, ctx) => {
-      if (event?.toolName !== 'claworld_manage_conversations') return;
+      const toolName = normalizeText(event?.toolName, null);
+      if (!toolName || !toolName.startsWith('claworld_')) return;
       const params = event?.params && typeof event.params === 'object' && !Array.isArray(event.params)
         ? event.params
         : {};
-      if (normalizeTerminalConversationAction(params.action, null) !== 'request') return;
       const requesterSessionKey = normalizeText(ctx?.sessionKey, null);
-      if (!requesterSessionKey) return;
+      if (
+        toolName !== 'claworld_manage_conversations'
+        || normalizeTerminalConversationAction(params.action, null) !== 'request'
+        || !requesterSessionKey
+      ) {
+        return;
+      }
+      const logger = getHookLogger(api);
+      try {
+        const workspaceRoot = await resolveHookWorkspaceRoot(api, event, ctx);
+        if (workspaceRoot) {
+          await updateClaworldSessionDirectory(
+            workspaceRoot,
+            {
+              timestamp: event?.timestamp || ctx?.timestamp || null,
+              source: 'claworld_hook',
+              eventType: 'before_tool_call',
+              kind: toolName,
+              toolName,
+              relations: {
+                localSessionKey: requesterSessionKey,
+                sessionKey: requesterSessionKey,
+                localAgentId: normalizeText(ctx?.agentId ?? ctx?.AgentId, null),
+              },
+              context: ctx || {},
+            },
+          );
+        }
+      } catch (error) {
+        logger?.warn?.('[claworld:working-memory] unable to update requester session directory', error);
+      }
       return {
         params: {
           ...params,
@@ -2252,6 +2283,7 @@ export function registerClaworldPluginFull(api, plugin) {
           params: event?.params || {},
           result: hookToolResult(event),
           timestamp: event?.timestamp || ctx?.timestamp || null,
+          context: ctx || {},
         });
         if (!maintenanceEvent) return;
         await appendClaworldJournalEvent(workspaceRoot, maintenanceEvent);

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

@@ -95,13 +95,23 @@ export function buildInboundEnvelope(message = {}) {
       'text',
       'body',
       'notification',
+      'conversationKey',
+      'worldId',
     ]) {
       if (payload[key] == null && data[key] != null) payload[key] = data[key];
     }
   }
+  const notification = payload.notification && typeof payload.notification === 'object' && !Array.isArray(payload.notification)
+    ? payload.notification
+    : data.notification && typeof data.notification === 'object' && !Array.isArray(data.notification)
+      ? data.notification
+      : {};
   const targetAgentId = normalizeEnvelopeText(
     data.targetAgentId,
-    normalizeEnvelopeText(payload.targetAgentId, null),
+    normalizeEnvelopeText(
+      payload.targetAgentId,
+      normalizeEnvelopeText(notification.targetAgentId, normalizeEnvelopeText(metadata.targetAgentId, null)),
+    ),
   );
   const sessionKey = normalizeEnvelopeText(
     data.sessionKey,
@@ -109,23 +119,45 @@ export function buildInboundEnvelope(message = {}) {
       payload.sessionKey,
       normalizeEnvelopeText(
         data.targetSessionKey,
-        normalizeEnvelopeText(payload.targetSessionKey, null),
+        normalizeEnvelopeText(
+          payload.targetSessionKey,
+          normalizeEnvelopeText(notification.targetSessionKey, normalizeEnvelopeText(metadata.sessionKey, null)),
+        ),
       ),
     ),
   );
   const isDeliveryEvent = message.event === 'delivery';
   const isRoutableEvent = Boolean(eventType && sessionKey);
   if (!isDeliveryEvent && !isRoutableEvent) return null;
+  const deliveryId = resolveEnvelopeMessageId(data, payload);
+  const eventName = normalizeEnvelopeText(
+    data.eventName,
+    normalizeEnvelopeText(payload.eventName, isDeliveryEvent ? null : normalizeEnvelopeText(message.event, null)),
+  );
   return {
     eventType: eventType || 'delivery',
-    deliveryId: resolveEnvelopeMessageId(data, payload),
+    eventName,
+    eventId: deliveryId,
+    deliveryId,
     sessionKey,
     targetAgentId,
-    createdAt: data.createdAt || data.availableAt || null,
-    updatedAt: data.updatedAt || null,
+    conversationKey: normalizeEnvelopeText(
+      data.conversationKey,
+      normalizeEnvelopeText(payload.conversationKey, normalizeEnvelopeText(notification.relatedObjects?.conversationKey, null)),
+    ),
+    worldId: normalizeEnvelopeText(
+      data.worldId,
+      normalizeEnvelopeText(payload.worldId, normalizeEnvelopeText(notification.relatedObjects?.worldId, null)),
+    ),
+    createdAt: data.createdAt || payload.createdAt || data.availableAt || payload.availableAt || notification.createdAt || null,
+    updatedAt: data.updatedAt || payload.updatedAt || notification.updatedAt || null,
     turnCreatedAt: data.turnCreatedAt || null,
     payload,
-    metadata,
+    metadata: {
+      ...metadata,
+      relayEvent: normalizeEnvelopeText(message.event, null),
+      inboxItemId: normalizeEnvelopeText(data.inboxItemId, normalizeEnvelopeText(payload.inboxItemId, null)),
+    },
   };
 }
 

package/src/openclaw/protocol/relay-event-protocol.js

@@ -21,16 +21,17 @@ export function createRelayEventProtocol() {
     describeEvent(event = {}) {
       const payload = normalizePayload(event.payload);
       const missing = [];
-      if (normalizeText(event.eventType, null) !== DELIVERY_EVENT_TYPE) {
+      const eventType = normalizeText(event.eventType, null);
+      if (eventType !== DELIVERY_EVENT_TYPE) {
         missing.push('eventType');
       }
-      if (!normalizeText(event.deliveryId, null)) {
+      if (eventType === DELIVERY_EVENT_TYPE && !normalizeText(event.deliveryId, null)) {
         missing.push('deliveryId');
       }
       if (!normalizeText(event.sessionKey, null)) {
         missing.push('sessionKey');
       }
-      if (!normalizeText(payload.text, null)) {
+      if (eventType === DELIVERY_EVENT_TYPE && !normalizeText(payload.text, null)) {
         missing.push('payload.text');
       }
       return {

package/src/openclaw/runtime/inbound-session-router.js

@@ -22,7 +22,6 @@ export function createInboundSessionRouter() {
       const target = resolveRuntimeSessionTarget(event, options);
       const sessionKey = target.sessionKey;
       return {
-        action: target.sessionKind === 'management' ? 'route_management_input' : 'route_delivery',
         target: target.target,
         fallbackTarget: normalizeText(options.fallbackTarget, 'mainagent'),
         sessionKind: target.sessionKind,

package/src/openclaw/runtime/session-routing.js

@@ -44,13 +44,18 @@ export function buildConversationSessionKey(conversationKey = null, fallbackSess
   return normalizeText(fallbackSessionKey, null);
 }
 
+function resolveSessionKindFromSessionKey(sessionKey = null) {
+  const normalizedSessionKey = normalizeText(sessionKey, null);
+  if (!normalizedSessionKey) return null;
+  const lowerSessionKey = normalizedSessionKey.toLowerCase();
+  if (lowerSessionKey.startsWith('management:') || lowerSessionKey.includes(':management:')) {
+    return CLAWORLD_SESSION_KINDS.management;
+  }
+  return CLAWORLD_SESSION_KINDS.conversation;
+}
+
 export function resolveRuntimeSessionTarget(event = {}, options = {}) {
   const payload = normalizePayload(event.payload);
-  const eventType = normalizeText(event.eventType || event.type || payload.eventType, null);
-  const providedSessionKind = normalizeText(
-    event.sessionKind,
-    normalizeText(payload.sessionKind, normalizeText(options.sessionKind, null)),
-  );
   const targetAgentId = normalizeText(
     event.targetAgentId,
     normalizeText(payload.targetAgentId, normalizeText(options.targetAgentId, null)),
@@ -63,16 +68,17 @@ export function resolveRuntimeSessionTarget(event = {}, options = {}) {
     event.sessionKey,
     normalizeText(payload.sessionKey, normalizeText(options.sessionKey, null)),
   );
+  const sessionKind = resolveSessionKindFromSessionKey(providedSessionKey);
 
-  if (providedSessionKind === CLAWORLD_SESSION_KINDS.management || CLAWORLD_MANAGEMENT_EVENT_TYPES.includes(eventType)) {
-    const managementSessionKey = normalizeText(
+  if (sessionKind === CLAWORLD_SESSION_KINDS.management) {
+    const managementSessionKey = normalizeText(providedSessionKey, normalizeText(
       options.managementSessionKey,
-      normalizeText(providedSessionKey, buildManagementSessionKey(targetAgentId)),
-    );
+      buildManagementSessionKey(targetAgentId),
+    ));
     return {
       sessionKind: CLAWORLD_SESSION_KINDS.management,
       target: normalizeText(options.managementTarget, 'management_session'),
-      sessionKey: providedSessionKey || managementSessionKey,
+      sessionKey: providedSessionKey,
       managementSessionKey: managementSessionKey || null,
       conversationSessionKey: conversationKey ? buildConversationSessionKey(conversationKey) : null,
       targetAgentId,
@@ -85,7 +91,9 @@ export function resolveRuntimeSessionTarget(event = {}, options = {}) {
     sessionKind: CLAWORLD_SESSION_KINDS.conversation,
     target: normalizeText(options.sessionTarget, 'conversation_session'),
     sessionKey: conversationSessionKey,
-    managementSessionKey: targetAgentId ? buildManagementSessionKey(targetAgentId) : null,
+    managementSessionKey: conversationSessionKey && targetAgentId
+      ? buildManagementSessionKey(targetAgentId)
+      : null,
     conversationSessionKey,
     targetAgentId,
     conversationKey,