@xfxstudio/claworld 2026.4.30-testing.2 → 2026.5.3-testing.1

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

@@ -1,4 +1,5 @@
 import { randomUUID } from 'node:crypto';
+import path from 'node:path';
 
 import {
   applyRuntimeIdentity,
@@ -137,6 +138,35 @@ function resolveNormalizedText(value, fallback = null) {
   return normalizeClaworldText(value, fallback);
 }
 
+function resolveInboundMessageId({ delivery = {}, payload = {}, metadata = {} } = {}) {
+  const notification = payload.notification && typeof payload.notification === 'object' && !Array.isArray(payload.notification)
+    ? payload.notification
+    : delivery.notification && typeof delivery.notification === 'object' && !Array.isArray(delivery.notification)
+      ? delivery.notification
+      : {};
+  const candidates = [
+    delivery.deliveryId,
+    delivery.inboxItemId,
+    delivery.messageId,
+    delivery.eventId,
+    delivery.notificationId,
+    payload.deliveryId,
+    payload.inboxItemId,
+    payload.messageId,
+    payload.eventId,
+    payload.notificationId,
+    metadata.messageId,
+    metadata.eventId,
+    metadata.notificationId,
+    notification.notificationId,
+  ];
+  for (const candidate of candidates) {
+    const normalized = resolveNormalizedText(candidate, null);
+    if (normalized) return normalized;
+  }
+  return null;
+}
+
 function isAgentScopedSessionKey(sessionKey) {
   return /^agent:[^:]+:/i.test(String(sessionKey || ''));
 }
@@ -279,6 +309,7 @@ function parseBridgeTimestampMs(value) {
 
 function resolveBridgeDeliveryTimestampMs({ delivery = {}, metadata = {} } = {}) {
   return parseBridgeTimestampMs(delivery?.createdAt)
+    || parseBridgeTimestampMs(delivery?.availableAt)
     || parseBridgeTimestampMs(delivery?.turnCreatedAt)
     || parseBridgeTimestampMs(metadata?.createdAt)
     || Date.now();
@@ -1757,6 +1788,7 @@ function buildDeliveryInboundEnvelope({
   commandText = null,
   timestamp = null,
   deliveryId,
+  eventType = 'delivery',
   sessionKey,
   localSessionKey = null,
   worldId = null,
@@ -1775,13 +1807,16 @@ function buildDeliveryInboundEnvelope({
   const normalizedCommandText = String(commandText || '').trim();
   const commandBody = normalizedCommandText || rawBody;
   const bodyForAgent = bodyText || rawBody;
+  const eventLabel = normalizePluginOptionalText(eventType) === 'delivery'
+    ? 'delivery'
+    : `event ${normalizePluginOptionalText(eventType)}`;
   const contextLines = mergeUntrustedContextLines([
     `[claworld peer ${remoteLabel}]`,
     ...(worldId ? [`[claworld world ${worldId}]`] : []),
     ...(conversationKey ? [`[claworld conversation ${conversationKey}]`] : []),
     ...(localSessionKey && localSessionKey !== sessionKey ? [`[claworld local session ${localSessionKey}]`] : []),
     `[claworld relay session ${sessionKey}]`,
-    `[claworld delivery ${deliveryId}]`,
+    `[claworld ${eventLabel} ${deliveryId}]`,
   ], untrustedContext);
   const envelopeTimestamp = Number.isFinite(timestamp) ? new Date(timestamp) : new Date();
 
@@ -1887,34 +1922,189 @@ function buildManagementRuntimeEventBody(details = {}, { localSessionKey = null
   return lines.join('\n');
 }
 
-function resolveSessionRecordArtifacts(record = null, fallbackStorePath = null) {
+function normalizeSessionStoreKey(value) {
+  return resolveNormalizedText(value, '').toLowerCase();
+}
+
+function resolveSessionStoreEntry(store = null, sessionKey = null) {
+  if (!store || typeof store !== 'object' || Array.isArray(store)) return null;
+  const normalizedSessionKey = resolveNormalizedText(sessionKey, null);
+  if (!normalizedSessionKey) return null;
+  if (store[normalizedSessionKey] && typeof store[normalizedSessionKey] === 'object') {
+    return store[normalizedSessionKey];
+  }
+  const lowerSessionKey = normalizeSessionStoreKey(normalizedSessionKey);
+  if (store[lowerSessionKey] && typeof store[lowerSessionKey] === 'object') {
+    return store[lowerSessionKey];
+  }
+  const match = Object.entries(store).find(([key, value]) => (
+    normalizeSessionStoreKey(key) === lowerSessionKey
+    && value
+    && typeof value === 'object'
+    && !Array.isArray(value)
+  ));
+  return match ? match[1] : null;
+}
+
+function readRuntimeSessionStoreEntry({ runtime = null, sessionStorePath = null, sessionKey = null } = {}) {
+  if (!runtime?.agent?.session?.loadSessionStore || !sessionStorePath || !sessionKey) return null;
+  try {
+    return resolveSessionStoreEntry(
+      runtime.agent.session.loadSessionStore(sessionStorePath),
+      sessionKey,
+    );
+  } catch {
+    return null;
+  }
+}
+
+function resolveSessionFilePathFromRuntime({
+  runtime = null,
+  sessionId = null,
+  record = {},
+  sessionStorePath = null,
+  localAgentId = null,
+} = {}) {
+  const normalizedSessionId = resolveNormalizedText(sessionId, null);
+  if (!normalizedSessionId) return null;
+
+  const sessionsDir = sessionStorePath
+    ? path.dirname(path.resolve(sessionStorePath))
+    : null;
+  if (typeof runtime?.agent?.session?.resolveSessionFilePath === 'function') {
+    try {
+      const resolved = runtime.agent.session.resolveSessionFilePath(
+        normalizedSessionId,
+        record,
+        {
+          ...(sessionsDir ? { sessionsDir } : {}),
+          ...(localAgentId ? { agentId: localAgentId } : {}),
+        },
+      );
+      const normalized = resolveNormalizedText(resolved, null);
+      if (normalized) return normalized;
+    } catch {
+      // Fall through to the local derivation below.
+    }
+  }
+
+  const candidate = resolveNormalizedText(record?.sessionFile, null);
+  if (candidate) {
+    if (path.isAbsolute(candidate) || !sessionsDir) return candidate;
+    return path.resolve(sessionsDir, candidate);
+  }
+
+  if (sessionsDir) {
+    return path.join(sessionsDir, `${normalizedSessionId}.jsonl`);
+  }
+  return null;
+}
+
+function resolveSessionRecordArtifacts(record = null, fallbackStorePath = null, options = {}) {
   const normalizedRecord = record && typeof record === 'object' && !Array.isArray(record) ? record : {};
   const nestedSession = normalizedRecord.session && typeof normalizedRecord.session === 'object' && !Array.isArray(normalizedRecord.session)
     ? normalizedRecord.session
     : {};
-  return {
-    sessionId: resolveNormalizedText(
-      normalizedRecord.sessionId,
-      resolveNormalizedText(nestedSession.sessionId, resolveNormalizedText(normalizedRecord.id, null)),
-    ),
-    sessionFile: resolveNormalizedText(
-      normalizedRecord.sessionFile,
+  const sessionId = resolveNormalizedText(
+    normalizedRecord.sessionId,
+    resolveNormalizedText(nestedSession.sessionId, resolveNormalizedText(normalizedRecord.id, null)),
+  );
+  const sessionStorePath = resolveNormalizedText(
+    normalizedRecord.storePath,
+    resolveNormalizedText(normalizedRecord.sessionStorePath, fallbackStorePath),
+  );
+  const directSessionFile = resolveNormalizedText(
+    normalizedRecord.sessionFile,
+    resolveNormalizedText(
+      normalizedRecord.sessionPath,
       resolveNormalizedText(
-        normalizedRecord.sessionPath,
-        resolveNormalizedText(
-          normalizedRecord.filePath,
-          resolveNormalizedText(normalizedRecord.path, resolveNormalizedText(nestedSession.filePath, null)),
-        ),
+        normalizedRecord.filePath,
+        resolveNormalizedText(normalizedRecord.path, resolveNormalizedText(nestedSession.filePath, null)),
       ),
     ),
-    sessionStorePath: resolveNormalizedText(
-      normalizedRecord.storePath,
-      resolveNormalizedText(normalizedRecord.sessionStorePath, fallbackStorePath),
-    ),
-    transcriptPath: resolveNormalizedText(
-      normalizedRecord.transcriptPath,
-      resolveNormalizedText(nestedSession.transcriptPath, null),
-    ),
+  );
+  const sessionFile = directSessionFile || resolveSessionFilePathFromRuntime({
+    runtime: options.runtime,
+    sessionId,
+    record: normalizedRecord,
+    sessionStorePath,
+    localAgentId: options.localAgentId,
+  });
+  const transcriptPath = resolveNormalizedText(
+    normalizedRecord.transcriptPath,
+    resolveNormalizedText(nestedSession.transcriptPath, sessionFile),
+  );
+  return {
+    sessionId,
+    sessionFile,
+    sessionStorePath,
+    transcriptPath,
+  };
+}
+
+async function recordRuntimeInboundSessionArtifacts({
+  runtime = null,
+  currentCfg = {},
+  localAgentId = null,
+  sessionKey = null,
+  ctx = {},
+  logger = console,
+  runtimeAccountId = null,
+  logLabel = 'inbound',
+  logContext = {},
+} = {}) {
+  let sessionStorePath = null;
+  let sessionRecord = null;
+  const sessionApi = runtime?.channel?.session || {};
+  const localSessionKey = resolveNormalizedText(ctx?.SessionKey, sessionKey);
+
+  if (sessionApi.resolveStorePath && localAgentId) {
+    sessionStorePath = sessionApi.resolveStorePath(currentCfg.session?.store, {
+      agentId: localAgentId,
+    });
+    const onRecordError = (error) => {
+      logger.error?.(`[claworld:${runtimeAccountId}] failed to record ${logLabel} inbound session`, {
+        ...logContext,
+        sessionKey,
+        localSessionKey,
+        localAgentId,
+        error: error?.message || String(error),
+      });
+    };
+    try {
+      if (typeof sessionApi.recordSessionMetaFromInbound === 'function') {
+        sessionRecord = await sessionApi.recordSessionMetaFromInbound({
+          storePath: sessionStorePath,
+          sessionKey: localSessionKey,
+          ctx,
+        });
+      } else if (typeof sessionApi.recordInboundSession === 'function') {
+        sessionRecord = await sessionApi.recordInboundSession({
+          storePath: sessionStorePath,
+          sessionKey: localSessionKey,
+          ctx,
+          onRecordError,
+        });
+      }
+    } catch (error) {
+      onRecordError(error);
+    }
+    if (!sessionRecord) {
+      sessionRecord = readRuntimeSessionStoreEntry({
+        runtime,
+        sessionStorePath,
+        sessionKey: localSessionKey,
+      });
+    }
+  }
+
+  return {
+    sessionStorePath,
+    sessionRecord,
+    sessionArtifacts: resolveSessionRecordArtifacts(sessionRecord, sessionStorePath, {
+      runtime,
+      localAgentId,
+    }),
   };
 }
 
@@ -2402,7 +2592,7 @@ function resolveBoundLocalAgentId({ cfg = {}, runtimeConfig = {}, relayClient }
     || 'main';
 }
 
-async function maybeBridgeRuntimeDelivery({
+async function maybeBridgeRuntimeInboundEvent({
   relayClient,
   runtimeConfig,
   runtimeAccountId,
@@ -2421,36 +2611,49 @@ async function maybeBridgeRuntimeDelivery({
   const payload = delivery.payload && typeof delivery.payload === 'object' && !Array.isArray(delivery.payload)
     ? delivery.payload
     : {};
-  const deliveryId = resolveNormalizedText(delivery.deliveryId, null);
+  const eventType = resolveNormalizedText(delivery.eventType, resolveNormalizedText(event?.eventType, 'delivery'));
+  const deliveryId = resolveInboundMessageId({ delivery, payload, metadata });
   const sessionKey = resolveNormalizedText(delivery.sessionKey, null);
+  const fallbackRuntimeEventText = eventType !== 'delivery'
+    ? buildManagementRuntimeEventBody(resolveRuntimeManagementEnvelope(event))
+    : null;
   const contextText = resolveNormalizedText(payload.contextText, null);
   const incomingText = resolveNormalizedText(
     payload.commandText,
-    contextText ? null : resolveNormalizedText(payload.text, null),
+    contextText ? null : resolveNormalizedText(payload.text, resolveNormalizedText(payload.body, fallbackRuntimeEventText)),
   );
   const commandText = resolveNormalizedText(payload.commandText, incomingText);
   const fromAgentId = resolveNormalizedText(metadata.fromAgentId, null);
-  const remoteIdentity = fromAgentId || 'unknown-peer';
+  const routeSessionKind = resolveNormalizedText(
+    event?.route?.sessionKind,
+    resolveNormalizedText(delivery.sessionKind, resolveNormalizedText(payload.sessionKind, null)),
+  );
+  const isRelayDelivery = eventType === 'delivery';
+  const allowReply = metadata.allowReply === true || (isRelayDelivery && metadata.allowReply !== false);
+  const remoteIdentity = fromAgentId
+    || resolveNormalizedText(metadata.source, routeSessionKind === 'management' ? 'claworld-management' : 'unknown-peer');
 
   if (
     !runtime?.channel?.reply?.finalizeInboundContext
     || !runtime?.channel?.reply?.dispatchReplyFromConfig
     || !runtime?.channel?.reply?.createReplyDispatcherWithTyping
   ) {
-    logger.warn?.(`[claworld:${runtimeAccountId}] skipping delivery bridge: missing runtime bridge hooks`, {
+    logger.warn?.(`[claworld:${runtimeAccountId}] skipping inbound bridge: missing runtime bridge hooks`, {
+      eventType,
       deliveryId,
       sessionKey,
     });
     return { skipped: true, reason: 'missing_runtime_bridge_hooks' };
   }
   if (!deliveryId || !sessionKey || (!incomingText && !contextText)) {
-    logger.warn?.(`[claworld:${runtimeAccountId}] skipping delivery bridge: missing delivery payload`, {
+    logger.warn?.(`[claworld:${runtimeAccountId}] skipping inbound bridge: missing payload`, {
+      eventType,
       deliveryId,
       sessionKey,
       hasIncomingText: Boolean(incomingText),
       hasContextText: Boolean(contextText),
     });
-    return { skipped: true, reason: 'missing_delivery_payload' };
+    return { skipped: true, reason: 'missing_inbound_payload' };
   }
 
   const loadedCfg = await runtime.config?.loadConfig?.() || {};
@@ -2476,7 +2679,7 @@ async function maybeBridgeRuntimeDelivery({
     fallbackTarget: runtimeConfig.routing?.fallbackTarget,
   }) || null;
   const worldId = resolveDeliveryWorldId(delivery);
-  const commandAuthorized = shouldAuthorizeBridgedCommand({
+  const commandAuthorized = isRelayDelivery && shouldAuthorizeBridgedCommand({
     runtimeConfig,
     incomingText: commandText || incomingText,
   });
@@ -2490,6 +2693,7 @@ async function maybeBridgeRuntimeDelivery({
     commandText,
     timestamp: inboundTimestamp,
     deliveryId,
+    eventType,
     sessionKey,
     localSessionKey,
     worldId,
@@ -2497,6 +2701,9 @@ async function maybeBridgeRuntimeDelivery({
     untrustedContext: payload.untrustedContext,
   });
   const localIdentity = normalizeClaworldText(runtimeConfig.relay?.agentId, runtimeConfig.accountId);
+  const isManagementSession = routeSessionKind === 'management';
+  const senderName = isManagementSession ? 'Claworld' : remoteIdentity;
+  const conversationLabel = isManagementSession ? 'Claworld management' : remoteIdentity;
   const inboundCtx = runtime.channel.reply.finalizeInboundContext({
     Body,
     RawBody,
@@ -2511,45 +2718,38 @@ async function maybeBridgeRuntimeDelivery({
     OriginatingChannel: 'claworld',
     OriginatingFrom: remoteIdentity,
     OriginatingTo: remoteIdentity,
-    ChatType: 'direct',
-    SenderName: remoteIdentity,
+    ChatType: isManagementSession ? 'management' : 'direct',
+    SessionType: isManagementSession ? 'management' : 'direct',
+    sessionType: isManagementSession ? 'management' : 'direct',
+    sessionKind: isManagementSession ? 'management' : 'conversation',
+    SenderName: senderName,
     SenderId: remoteIdentity,
     MessageId: deliveryId,
     Provider: 'claworld',
     Surface: 'claworld',
-    ConversationLabel: remoteIdentity,
+    ConversationLabel: conversationLabel,
     Timestamp: inboundTimestamp,
     MessageSid: deliveryId,
     WasMentioned: false,
     CommandAuthorized: commandAuthorized,
-    RelayDeliveryId: deliveryId,
+    RelayDeliveryId: isRelayDelivery ? deliveryId : null,
     RelayFromAgentId: fromAgentId,
     UntrustedContext,
   });
 
-  let sessionStorePath = null;
-  let sessionRecord = null;
-  let sessionArtifacts = {};
-  if (runtime?.channel?.session?.recordInboundSession && runtime?.channel?.session?.resolveStorePath && localAgentId) {
-    sessionStorePath = runtime.channel.session.resolveStorePath(currentCfg.session?.store, {
-      agentId: localAgentId,
-    });
-    sessionRecord = await runtime.channel.session.recordInboundSession({
-      storePath: sessionStorePath,
-      sessionKey: inboundCtx.SessionKey || sessionKey,
-      ctx: inboundCtx,
-      onRecordError: (error) => {
-        logger.error?.(`[claworld:${runtimeAccountId}] failed to record inbound session`, {
-          deliveryId,
-          sessionKey,
-          localSessionKey,
-          localAgentId,
-          error: error?.message || String(error),
-        });
-      },
-    });
-    sessionArtifacts = resolveSessionRecordArtifacts(sessionRecord, sessionStorePath);
-  }
+  const {
+    sessionArtifacts,
+  } = await recordRuntimeInboundSessionArtifacts({
+    runtime,
+    currentCfg,
+    localAgentId,
+    sessionKey,
+    ctx: inboundCtx,
+    logger,
+    runtimeAccountId,
+    logLabel: isRelayDelivery ? 'delivery' : 'inbound',
+    logContext: { eventType, deliveryId },
+  });
 
   const workspaceRoot = resolveOpenClawWorkspaceRoot({
     sources: [
@@ -2563,9 +2763,8 @@ async function maybeBridgeRuntimeDelivery({
   let journalResult = null;
   if (workspaceRoot) {
     try {
-      journalResult = await appendClaworldJournalEvent(
-        workspaceRoot,
-        buildDeliveryRuntimeMaintenanceEvent({
+      const maintenanceEvent = isRelayDelivery
+        ? buildDeliveryRuntimeMaintenanceEvent({
           delivery,
           metadata,
           payload,
@@ -2573,14 +2772,24 @@ async function maybeBridgeRuntimeDelivery({
           localAgentId,
           sessionArtifacts,
           workspaceRoot,
-        }),
+        })
+        : buildManagementRuntimeMaintenanceEvent(resolveRuntimeManagementEnvelope(event), {
+          localSessionKey,
+          localAgentId,
+          sessionArtifacts,
+          workspaceRoot,
+        });
+      journalResult = await appendClaworldJournalEvent(
+        workspaceRoot,
+        maintenanceEvent,
         {
-          trigger: 'delivery',
-          rule: 'runtime_delivery_joined_session',
+          trigger: isRelayDelivery ? 'delivery' : 'runtime_event',
+          rule: isRelayDelivery ? 'runtime_delivery_joined_session' : 'runtime_event_joined_session',
         },
       );
     } catch (error) {
-      logger.warn?.(`[claworld:${runtimeAccountId}] delivery journal append failed`, {
+      logger.warn?.(`[claworld:${runtimeAccountId}] inbound journal append failed`, {
+        eventType,
         deliveryId,
         sessionKey,
         localSessionKey,
@@ -2590,7 +2799,8 @@ async function maybeBridgeRuntimeDelivery({
     }
   }
 
-  logger.info?.(`[claworld:${runtimeAccountId}] routing delivery into runtime session`, {
+  logger.info?.(`[claworld:${runtimeAccountId}] ${isRelayDelivery ? 'routing delivery into runtime session' : 'routing inbound event into runtime session'}`, {
+    eventType,
     deliveryId,
     sessionKey,
     localSessionKey,
@@ -2601,28 +2811,30 @@ async function maybeBridgeRuntimeDelivery({
     routeStatus: routed?.status || null,
     bodyPreview: String(Body || '').slice(0, 240),
     rawBodyPreview: String(RawBody || '').slice(0, 240),
-    allowReply: metadata.allowReply !== false,
+    allowReply,
     commandAuthorized,
     journal: journalResult?.ok === true,
   });
 
-  try {
-    const acceptedResult = await relayClient.acceptDeliveryHttp({
-      deliveryId,
-      sessionKey,
-      source: 'runtime_dispatch',
-    });
-    if (acceptedResult.status < 200 || acceptedResult.status >= 300) {
-      throw new Error(`failed to submit relay delivery acceptance: ${acceptedResult.status}`);
+  if (isRelayDelivery && metadata.acceptanceRequired !== false) {
+    try {
+      const acceptedResult = await relayClient.acceptDeliveryHttp({
+        deliveryId,
+        sessionKey,
+        source: 'runtime_dispatch',
+      });
+      if (acceptedResult.status < 200 || acceptedResult.status >= 300) {
+        throw new Error(`failed to submit relay delivery acceptance: ${acceptedResult.status}`);
+      }
+    } catch (error) {
+      logger.warn?.(`[claworld:${runtimeAccountId}] delivery acceptance acknowledgement failed`, {
+        deliveryId,
+        sessionKey,
+        localSessionKey,
+        localAgentId,
+        error: error?.message || String(error),
+      });
     }
-  } catch (error) {
-    logger.warn?.(`[claworld:${runtimeAccountId}] delivery acceptance acknowledgement failed`, {
-      deliveryId,
-      sessionKey,
-      localSessionKey,
-      localAgentId,
-      error: error?.message || String(error),
-    });
   }
 
   let {
@@ -2637,15 +2849,16 @@ async function maybeBridgeRuntimeDelivery({
     deliveryId,
     sessionKey,
     localAgentId,
-    allowReply: metadata.allowReply !== false,
+    allowReply,
     logger,
     runtimeAccountId,
     inboundCtx,
   });
 
   const shouldRetryKickoffDispatch = (
-    metadata.deliveryType === 'kickoff'
-    && metadata.allowReply !== false
+    isRelayDelivery
+    && metadata.deliveryType === 'kickoff'
+    && allowReply
     && replied !== true
     && runtimeOutputSummary.counts.final > 0
     && runtimeOutputSummary.counts.nonRenderableFinal > 0
@@ -2682,14 +2895,15 @@ async function maybeBridgeRuntimeDelivery({
       deliveryId,
       sessionKey,
       localAgentId,
-      allowReply: metadata.allowReply !== false,
+      allowReply,
       logger,
       runtimeAccountId,
       inboundCtx,
     }));
   }
 
-  logger.info?.(`[claworld:${runtimeAccountId}] delivery bridge completed`, {
+  logger.info?.(`[claworld:${runtimeAccountId}] ${isRelayDelivery ? 'delivery bridge completed' : 'inbound bridge completed'}`, {
+    eventType,
     deliveryId,
     sessionKey,
     localSessionKey,
@@ -2806,30 +3020,23 @@ async function maybeBridgeRuntimeManagementEvent({
     RelayTargetAgentId: details.targetAgentId,
   });
 
-  let sessionStorePath = null;
-  let sessionRecord = null;
-  let sessionArtifacts = {};
-  if (runtime?.channel?.session?.recordInboundSession && runtime?.channel?.session?.resolveStorePath && localAgentId) {
-    sessionStorePath = runtime.channel.session.resolveStorePath(currentCfg.session?.store, {
-      agentId: localAgentId,
-    });
-    sessionRecord = await runtime.channel.session.recordInboundSession({
-      storePath: sessionStorePath,
-      sessionKey: inboundCtx.SessionKey || sessionKey,
-      ctx: inboundCtx,
-      onRecordError: (error) => {
-        logger.error?.(`[claworld:${runtimeAccountId}] failed to record management inbound session`, {
-          eventType: details.eventType,
-          eventName: details.eventName,
-          sessionKey,
-          localSessionKey,
-          localAgentId,
-          error: error?.message || String(error),
-        });
-      },
-    });
-    sessionArtifacts = resolveSessionRecordArtifacts(sessionRecord, sessionStorePath);
-  }
+  const {
+    sessionStorePath,
+    sessionArtifacts,
+  } = await recordRuntimeInboundSessionArtifacts({
+    runtime,
+    currentCfg,
+    localAgentId,
+    sessionKey,
+    ctx: inboundCtx,
+    logger,
+    runtimeAccountId,
+    logLabel: 'management',
+    logContext: {
+      eventType: details.eventType,
+      eventName: details.eventName,
+    },
+  });
 
   const workspaceRoot = resolveOpenClawWorkspaceRoot({
     sources: [
@@ -3350,9 +3557,9 @@ export function createClaworldChannelPlugin({
             sessionKey: event?.delivery?.sessionKey || null,
           });
 
-          if (event?.eventType === 'delivery') {
+          if (event?.delivery?.sessionKey) {
             const runtimeContext = accountRuntimeContexts.get(accountKey) || {};
-            maybeBridgeRuntimeDelivery({
+            maybeBridgeRuntimeInboundEvent({
               relayClient,
               runtimeConfig,
               runtimeAccountId,
@@ -3362,7 +3569,7 @@ export function createClaworldChannelPlugin({
               cfg: runtimeContext.cfg,
               inbound,
             }).catch((error) => {
-              logger.error?.(`[claworld:${runtimeAccountId}] delivery bridge exception`, {
+              logger.error?.(`[claworld:${runtimeAccountId}] inbound bridge exception`, {
                 error: error?.message || String(error),
               });
             });
@@ -3523,7 +3730,8 @@ export function createClaworldChannelPlugin({
   }
 
 async function updateRuntimePublicIdentity(context = {}) {
-    const resolvedContext = resolveConfiguredRuntimeContext(context);
+    const configuredContext = resolveConfiguredRuntimeContext(context);
+    const resolvedContext = await resolveBoundRuntimeContext(context);
     const updateResult = await updatePublicIdentity({
       runtimeConfig: resolvedContext.runtimeConfig,
       agentId: resolvedContext.agentId || null,
@@ -3553,14 +3761,20 @@ async function updateRuntimePublicIdentity(context = {}) {
       ? applyRuntimeIdentity(nextRuntimeConfig, { agentId: nextAgentId })
       : nextRuntimeConfig;
 
+    const configuredAppToken = resolveRuntimeAppToken(configuredContext.runtimeConfig);
     const previousAgentId = normalizeClaworldText(
-      resolvedContext.runtimeConfig?.relay?.agentId,
-      normalizeClaworldText(resolvedContext.agentId, null),
+      configuredContext.runtimeConfig?.relay?.agentId,
+      normalizeClaworldText(configuredContext.agentId, null),
     );
+    const nextAppToken = resolveRuntimeAppToken(boundRuntimeConfig);
     const shouldPersistRuntimeBinding = Boolean(
-      resolveRuntimeAppToken(nextRuntimeConfig)
+      nextAppToken
       && nextAgentId
-      && (runtimeActivation || previousAgentId !== nextAgentId),
+      && (
+        runtimeActivation
+        || configuredAppToken !== nextAppToken
+        || previousAgentId !== nextAgentId
+      ),
     );
 
     if (shouldPersistRuntimeBinding) {
@@ -3569,7 +3783,7 @@ async function updateRuntimePublicIdentity(context = {}) {
         await persistRuntimeAppToken({
           runtime: runtimeResolution.runtime,
           accountId: resolvedContext.accountId || boundRuntimeConfig.accountId || null,
-          appToken: resolveRuntimeAppToken(boundRuntimeConfig),
+          appToken: nextAppToken,
           relayAgentId: nextAgentId,
         });
       } catch (error) {
@@ -3582,7 +3796,9 @@ async function updateRuntimePublicIdentity(context = {}) {
       rememberAccountBinding({
         runtimeConfig: boundRuntimeConfig,
         accountId: resolvedContext.accountId || boundRuntimeConfig.accountId || null,
-        bindingSource: runtimeActivation ? 'activated_app_token' : 'configured_app_token',
+        bindingSource: runtimeActivation
+          ? 'activated_app_token'
+          : (resolvedContext.bindingSource || 'configured_app_token'),
       });
 
       const accountKey = resolveAccountBindingKey(boundRuntimeConfig, resolvedContext.accountId || null);