@xfxstudio/claworld 2026.4.30-testing.2 → 2026.4.30-testing.3

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

@@ -32,11 +32,6 @@ import { createInboundSessionRouter } from '../runtime/inbound-session-router.js
 import { createOutboundSessionBridge } from '../runtime/outbound-session-bridge.js';
 import { createCanonicalResultBuilder } from '../runtime/canonical-result-builder.js';
 import { createDemoSessionBootstrap } from '../runtime/demo-session-bootstrap.js';
-import {
-  appendClaworldJournalEvent,
-  buildClaworldRuntimeMaintenanceEvent,
-} from '../runtime/working-memory.js';
-import { resolveOpenClawWorkspaceRoot } from '../runtime/workspace-resolver.js';
 import {
   broadcastModeratedWorld,
   createModeratedWorld,
@@ -137,6 +132,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 +303,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 +1782,7 @@ function buildDeliveryInboundEnvelope({
   commandText = null,
   timestamp = null,
   deliveryId,
+  eventType = 'delivery',
   sessionKey,
   localSessionKey = null,
   worldId = null,
@@ -1775,13 +1801,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();
 
@@ -1812,230 +1841,6 @@ function buildDeliveryInboundEnvelope({
   };
 }
 
-function resolveRuntimeManagementEnvelope(event = {}) {
-  const envelope = event?.delivery && typeof event.delivery === 'object' && !Array.isArray(event.delivery)
-    ? event.delivery
-    : {};
-  const payload = envelope.payload && typeof envelope.payload === 'object' && !Array.isArray(envelope.payload)
-    ? envelope.payload
-    : {};
-  const notification = payload.notification && typeof payload.notification === 'object' && !Array.isArray(payload.notification)
-    ? payload.notification
-    : {};
-  return {
-    envelope,
-    payload,
-    notification,
-    eventType: resolveNormalizedText(envelope.eventType || payload.eventType || event.eventType, null),
-    eventName: resolveNormalizedText(envelope.eventName || payload.eventName || notification.notificationType, null),
-    eventId: resolveNormalizedText(
-      envelope.eventId,
-      resolveNormalizedText(payload.inboxItemId, resolveNormalizedText(notification.notificationId, null)),
-    ),
-    sessionKey: resolveNormalizedText(envelope.sessionKey, resolveNormalizedText(payload.sessionKey, null)),
-    targetAgentId: resolveNormalizedText(
-      envelope.targetAgentId,
-      resolveNormalizedText(payload.targetAgentId, resolveNormalizedText(notification.targetAgentId, null)),
-    ),
-    worldId: resolveNormalizedText(envelope.worldId, resolveNormalizedText(payload.worldId, resolveNormalizedText(notification.relatedObjects?.worldId, null))),
-    conversationKey: resolveNormalizedText(
-      envelope.conversationKey,
-      resolveNormalizedText(payload.conversationKey, resolveNormalizedText(notification.relatedObjects?.conversationKey, null)),
-    ),
-    createdAt: envelope.createdAt || payload.createdAt || notification.createdAt || null,
-  };
-}
-
-function stableJsonPreview(value = null, maxChars = 1200) {
-  if (!value || typeof value !== 'object') return null;
-  let json;
-  try {
-    json = JSON.stringify(value, null, 2);
-  } catch {
-    return null;
-  }
-  if (json.length <= maxChars) return json;
-  return `${json.slice(0, Math.max(0, maxChars - 3))}...`;
-}
-
-function buildManagementRuntimeEventBody(details = {}, { localSessionKey = null } = {}) {
-  const notification = details.notification || {};
-  const relatedObjects = notification.relatedObjects || details.payload?.relatedObjects || null;
-  const nextActions = notification.nextActions || details.payload?.nextActions || null;
-  const lines = [
-    'Claworld management event received.',
-    '',
-    `Event type: ${details.eventType || 'unknown'}`,
-    `Event name: ${details.eventName || details.eventType || 'unknown'}`,
-    details.eventId ? `Event id: ${details.eventId}` : null,
-    `Management session: ${localSessionKey || details.sessionKey || 'unknown'}`,
-    details.targetAgentId ? `Target agent: ${details.targetAgentId}` : null,
-    details.worldId ? `World: ${details.worldId}` : null,
-    details.conversationKey ? `Conversation: ${details.conversationKey}` : null,
-    '',
-    notification.notificationType ? `Notification type: ${notification.notificationType}` : null,
-    notification.title ? `Title: ${notification.title}` : null,
-    notification.body ? `Body: ${notification.body}` : null,
-    notification.whyReceived ? `Why received: ${notification.whyReceived}` : null,
-    relatedObjects ? 'Related objects:' : null,
-    relatedObjects ? stableJsonPreview(relatedObjects, 900) : null,
-    Array.isArray(nextActions) && nextActions.length > 0 ? 'Next actions:' : null,
-    Array.isArray(nextActions) && nextActions.length > 0 ? stableJsonPreview(nextActions, 900) : null,
-    '',
-    'Handle this as a Claworld Management Session input: decide whether to record, digest, act, report, or ask the user according to the current Claworld working memory and proactivity settings.',
-  ].filter((line) => line != null && line !== '');
-  return lines.join('\n');
-}
-
-function resolveSessionRecordArtifacts(record = null, fallbackStorePath = null) {
-  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,
-      resolveNormalizedText(
-        normalizedRecord.sessionPath,
-        resolveNormalizedText(
-          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),
-    ),
-  };
-}
-
-function buildDeliveryRuntimeMaintenanceEvent({
-  delivery = {},
-  metadata = {},
-  payload = {},
-  localSessionKey = null,
-  localAgentId = null,
-  sessionArtifacts = {},
-  workspaceRoot = null,
-} = {}) {
-  const deliveryId = resolveNormalizedText(delivery.deliveryId, null);
-  const sessionKey = resolveNormalizedText(delivery.sessionKey, null);
-  const requestId = resolveNormalizedText(
-    metadata.kickoffRequestId,
-    resolveNormalizedText(metadata.requestId, resolveNormalizedText(metadata.chatRequestId, null)),
-  );
-  const worldId = resolveNormalizedText(
-    metadata.worldId,
-    resolveNormalizedText(delivery.worldId, null),
-  );
-  const conversationKey = resolveNormalizedText(metadata.conversationKey, resolveNormalizedText(delivery.conversationKey, null));
-  const fromAgentId = resolveNormalizedText(metadata.fromAgentId, null);
-  const summary = [
-    'Inbound Claworld delivery joined local session',
-    requestId ? `for request ${requestId}` : null,
-    fromAgentId ? `from ${fromAgentId}` : null,
-  ].filter(Boolean).join(' ');
-  return buildClaworldRuntimeMaintenanceEvent({
-    id: deliveryId ? `runtime:delivery:${deliveryId}` : null,
-    timestamp: delivery.createdAt || metadata.createdAt || payload.createdAt || null,
-    kind: metadata.deliveryType ? `delivery.${metadata.deliveryType}` : 'delivery',
-    eventType: 'delivery',
-    scope: 'conversation',
-    summary,
-    excerpt: payload.contextText
-      ? 'Inbound delivery included contextText; raw dialogue is kept in the OpenClaw session transcript.'
-      : 'Inbound delivery routed into an OpenClaw conversation session; raw dialogue is kept in the session transcript.',
-    refs: {
-      deliveryId,
-      requestId,
-      chatRequestId: requestId,
-      worldId,
-      conversationKey,
-      fromAgentId,
-      sessionKey: localSessionKey || sessionKey,
-      relaySessionKey: sessionKey,
-    },
-    relations: {
-      deliveryId,
-      requestId,
-      chatRequestId: requestId,
-      worldId,
-      conversationKey,
-      fromAgentId,
-      localAgentId,
-      localSessionKey,
-      relaySessionKey: sessionKey,
-      sessionKey: localSessionKey || sessionKey,
-      sessionId: sessionArtifacts.sessionId,
-      sessionFile: sessionArtifacts.sessionFile,
-      sessionStorePath: sessionArtifacts.sessionStorePath,
-      transcriptPath: sessionArtifacts.transcriptPath,
-    },
-    artifacts: {
-      workspaceRoot,
-      ...sessionArtifacts,
-    },
-  });
-}
-
-function buildManagementRuntimeMaintenanceEvent(details = {}, {
-  localSessionKey = null,
-  localAgentId = null,
-  sessionArtifacts = {},
-  workspaceRoot = null,
-} = {}) {
-  const notification = details.notification || {};
-  const refs = {
-    inboxItemId: details.payload?.inboxItemId || details.eventId,
-    notificationId: notification.notificationId,
-    notificationType: notification.notificationType || details.payload?.notificationType,
-    worldId: details.worldId,
-    conversationKey: details.conversationKey,
-    targetAgentId: details.targetAgentId,
-    sessionKey: localSessionKey || details.sessionKey,
-    relaySessionKey: details.sessionKey,
-  };
-  return buildClaworldRuntimeMaintenanceEvent({
-    id: details.eventId ? `runtime:${details.eventType}:${details.eventId}` : null,
-    timestamp: details.createdAt || notification.createdAt || null,
-    kind: details.eventName || details.eventType || 'runtime_event',
-    eventType: details.eventType || 'runtime_event',
-    scope: 'management',
-    summary: notification.title || notification.body || `${details.eventType || 'runtime'} event received.`,
-    excerpt: buildManagementRuntimeEventBody(details),
-    refs,
-    relations: {
-      inboxItemId: refs.inboxItemId,
-      notificationId: refs.notificationId,
-      notificationType: refs.notificationType,
-      worldId: details.worldId,
-      conversationKey: details.conversationKey,
-      targetAgentId: details.targetAgentId,
-      localAgentId,
-      localSessionKey,
-      relaySessionKey: details.sessionKey,
-      sessionKey: localSessionKey || details.sessionKey,
-      sessionId: sessionArtifacts.sessionId,
-      sessionFile: sessionArtifacts.sessionFile,
-      sessionStorePath: sessionArtifacts.sessionStorePath,
-      transcriptPath: sessionArtifacts.transcriptPath,
-    },
-    artifacts: {
-      workspaceRoot,
-      ...sessionArtifacts,
-    },
-  });
-}
-
 function createDeliveryReplyDispatcher({
   runtime,
   currentCfg,
@@ -2402,7 +2207,7 @@ function resolveBoundLocalAgentId({ cfg = {}, runtimeConfig = {}, relayClient }
     || 'main';
 }
 
-async function maybeBridgeRuntimeDelivery({
+async function maybeBridgeRuntimeInboundEvent({
   relayClient,
   runtimeConfig,
   runtimeAccountId,
@@ -2421,36 +2226,46 @@ 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 contextText = resolveNormalizedText(payload.contextText, null);
   const incomingText = resolveNormalizedText(
     payload.commandText,
-    contextText ? null : resolveNormalizedText(payload.text, null),
+    contextText ? null : resolveNormalizedText(payload.text, resolveNormalizedText(payload.body, null)),
   );
   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 +2291,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 +2305,7 @@ async function maybeBridgeRuntimeDelivery({
     commandText,
     timestamp: inboundTimestamp,
     deliveryId,
+    eventType,
     sessionKey,
     localSessionKey,
     worldId,
@@ -2497,6 +2313,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,35 +2330,33 @@ async function maybeBridgeRuntimeDelivery({
     OriginatingChannel: 'claworld',
     OriginatingFrom: remoteIdentity,
     OriginatingTo: remoteIdentity,
-    ChatType: 'direct',
-    SenderName: remoteIdentity,
+    ChatType: isManagementSession ? 'management' : 'direct',
+    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, {
+    const storePath = runtime.channel.session.resolveStorePath(currentCfg.session?.store, {
       agentId: localAgentId,
     });
-    sessionRecord = await runtime.channel.session.recordInboundSession({
-      storePath: sessionStorePath,
+    await runtime.channel.session.recordInboundSession({
+      storePath,
       sessionKey: inboundCtx.SessionKey || sessionKey,
       ctx: inboundCtx,
       onRecordError: (error) => {
         logger.error?.(`[claworld:${runtimeAccountId}] failed to record inbound session`, {
+          eventType,
           deliveryId,
           sessionKey,
           localSessionKey,
@@ -2548,81 +2365,41 @@ async function maybeBridgeRuntimeDelivery({
         });
       },
     });
-    sessionArtifacts = resolveSessionRecordArtifacts(sessionRecord, sessionStorePath);
   }
 
-  const workspaceRoot = resolveOpenClawWorkspaceRoot({
-    sources: [
-      { agentId: localAgentId, localAgentId },
-      currentCfg,
-      runtimeConfig,
-    ],
-    config: currentCfg,
-    agentId: localAgentId,
-  });
-  let journalResult = null;
-  if (workspaceRoot) {
-    try {
-      journalResult = await appendClaworldJournalEvent(
-        workspaceRoot,
-        buildDeliveryRuntimeMaintenanceEvent({
-          delivery,
-          metadata,
-          payload,
-          localSessionKey,
-          localAgentId,
-          sessionArtifacts,
-          workspaceRoot,
-        }),
-        {
-          trigger: 'delivery',
-          rule: 'runtime_delivery_joined_session',
-        },
-      );
-    } catch (error) {
-      logger.warn?.(`[claworld:${runtimeAccountId}] delivery journal append failed`, {
-        deliveryId,
-        sessionKey,
-        localSessionKey,
-        localAgentId,
-        error: error?.message || String(error),
-      });
-    }
-  }
-
-  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,
     localAgentId,
-    sessionId: sessionArtifacts.sessionId || null,
-    sessionFile: sessionArtifacts.sessionFile || null,
     remoteIdentity,
     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 +2414,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 +2460,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,
@@ -2712,206 +2491,6 @@ async function maybeBridgeRuntimeDelivery({
   };
 }
 
-async function maybeBridgeRuntimeManagementEvent({
-  runtimeConfig,
-  runtimeAccountId,
-  event,
-  logger,
-  runtime,
-  cfg,
-  inbound,
-}) {
-  const details = resolveRuntimeManagementEnvelope(event);
-  const route = event?.route || inbound?.routeInboundEvent?.(details.envelope, {
-    sessionTarget: runtimeConfig.routing?.sessionTarget,
-    fallbackTarget: runtimeConfig.routing?.fallbackTarget,
-  }) || null;
-  const sessionKey = resolveNormalizedText(details.sessionKey, resolveNormalizedText(route?.sessionKey, null));
-  const eventId = resolveNormalizedText(details.eventId, `${details.eventType || 'runtime_event'}:${Date.now()}`);
-
-  if (
-    !runtime?.channel?.reply?.finalizeInboundContext
-    || !runtime?.channel?.reply?.dispatchReplyFromConfig
-    || !runtime?.channel?.reply?.createReplyDispatcherWithTyping
-  ) {
-    logger.warn?.(`[claworld:${runtimeAccountId}] skipping management event bridge: missing runtime bridge hooks`, {
-      eventType: details.eventType,
-      eventName: details.eventName,
-      sessionKey,
-    });
-    return { skipped: true, reason: 'missing_runtime_bridge_hooks' };
-  }
-  if (!details.eventType || !sessionKey || route?.status === 'invalid') {
-    logger.warn?.(`[claworld:${runtimeAccountId}] skipping management event bridge: missing runtime event payload`, {
-      eventType: details.eventType,
-      eventName: details.eventName,
-      sessionKey,
-      routeStatus: route?.status || null,
-    });
-    return { skipped: true, reason: 'missing_management_event_payload' };
-  }
-
-  const loadedCfg = await runtime.config?.loadConfig?.() || {};
-  const currentCfg = {
-    ...(loadedCfg && typeof loadedCfg === 'object' && !Array.isArray(loadedCfg) ? loadedCfg : {}),
-    ...(cfg && typeof cfg === 'object' && !Array.isArray(cfg) ? cfg : {}),
-    agents: cfg?.agents || loadedCfg?.agents,
-    bindings: cfg?.bindings || loadedCfg?.bindings,
-    channels: cfg?.channels || loadedCfg?.channels,
-    session: cfg?.session || loadedCfg?.session,
-  };
-  const localAgentId = resolveBoundLocalAgentId({
-    cfg: currentCfg,
-    runtimeConfig,
-  });
-  const localSessionKey = buildAgentScopedLocalSessionKey({
-    sessionKey,
-    localAgentId,
-  });
-  const body = buildManagementRuntimeEventBody(details, { localSessionKey });
-  const timestamp = Date.parse(details.createdAt || '');
-  const inboundTimestamp = Number.isFinite(timestamp) ? timestamp : Date.now();
-  const localIdentity = normalizeClaworldText(runtimeConfig.relay?.agentId, runtimeConfig.accountId);
-  const inboundCtx = runtime.channel.reply.finalizeInboundContext({
-    Body: body,
-    RawBody: body,
-    CommandBody: body,
-    BodyForAgent: body,
-    BodyForCommands: body,
-    From: 'claworld:management',
-    To: `claworld:${localIdentity}`,
-    SessionKey: localSessionKey || sessionKey,
-    RelaySessionKey: sessionKey,
-    AccountId: runtimeConfig.accountId,
-    OriginatingChannel: 'claworld',
-    OriginatingFrom: 'management',
-    OriginatingTo: localIdentity,
-    ChatType: 'management',
-    SessionType: 'management',
-    sessionType: 'management',
-    sessionKind: 'management',
-    SenderName: 'Claworld Management',
-    SenderId: 'claworld-management',
-    MessageId: eventId,
-    Provider: 'claworld',
-    Surface: 'claworld',
-    ConversationLabel: 'Claworld Management',
-    Timestamp: inboundTimestamp,
-    MessageSid: eventId,
-    WasMentioned: false,
-    CommandAuthorized: false,
-    RelayEventId: eventId,
-    RelayEventType: details.eventType,
-    RelayEventName: details.eventName,
-    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 workspaceRoot = resolveOpenClawWorkspaceRoot({
-    sources: [
-      { agentId: localAgentId, localAgentId },
-      currentCfg,
-      runtimeConfig,
-    ],
-    config: currentCfg,
-    agentId: localAgentId,
-  });
-  let journalResult = null;
-  if (workspaceRoot) {
-    try {
-      journalResult = await appendClaworldJournalEvent(
-        workspaceRoot,
-        buildManagementRuntimeMaintenanceEvent(details, {
-          localSessionKey,
-          localAgentId,
-          sessionArtifacts,
-          workspaceRoot,
-        }),
-      );
-    } catch (error) {
-      logger.warn?.(`[claworld:${runtimeAccountId}] management event journal append failed`, {
-        eventType: details.eventType,
-        eventName: details.eventName,
-        sessionKey,
-        error: error?.message || String(error),
-      });
-    }
-  }
-
-  logger.info?.(`[claworld:${runtimeAccountId}] routing management event into runtime session`, {
-    eventType: details.eventType,
-    eventName: details.eventName,
-    eventId,
-    sessionKey,
-    localSessionKey,
-    localAgentId,
-    sessionId: sessionArtifacts.sessionId || null,
-    sessionFile: sessionArtifacts.sessionFile || null,
-    routeStatus: route?.status || null,
-    journal: journalResult?.ok === true,
-  });
-
-  const {
-    dispatchResult,
-    runtimeOutputSummary,
-  } = await runDeliveryReplyDispatch({
-    runtime,
-    currentCfg,
-    relayClient: null,
-    deliveryId: eventId,
-    sessionKey,
-    localAgentId,
-    allowReply: false,
-    logger,
-    runtimeAccountId,
-    inboundCtx,
-  });
-
-  logger.info?.(`[claworld:${runtimeAccountId}] management event bridge completed`, {
-    eventType: details.eventType,
-    eventName: details.eventName,
-    eventId,
-    sessionKey,
-    localSessionKey,
-    queuedFinal: Boolean(dispatchResult?.queuedFinal),
-    routeStatus: route?.status || null,
-    runtimeOutputSummary,
-  });
-
-  return {
-    skipped: false,
-    ok: true,
-    queuedFinal: Boolean(dispatchResult?.queuedFinal),
-    sessionKey,
-    localSessionKey,
-    routeStatus: route?.status || null,
-  };
-}
-
 export function createClaworldChannelPlugin({
   logger = console,
   relayClientFactory = createClaworldRelayClient,
@@ -3346,13 +2925,12 @@ export function createClaworldChannelPlugin({
             eventType: event?.eventType || null,
             target: event?.route?.target || null,
             deliveryId: event?.delivery?.deliveryId || null,
-            eventId: event?.delivery?.eventId || null,
             sessionKey: event?.delivery?.sessionKey || null,
           });
 
-          if (event?.eventType === 'delivery') {
+          if (event?.delivery?.sessionKey) {
             const runtimeContext = accountRuntimeContexts.get(accountKey) || {};
-            maybeBridgeRuntimeDelivery({
+            maybeBridgeRuntimeInboundEvent({
               relayClient,
               runtimeConfig,
               runtimeAccountId,
@@ -3362,22 +2940,7 @@ export function createClaworldChannelPlugin({
               cfg: runtimeContext.cfg,
               inbound,
             }).catch((error) => {
-              logger.error?.(`[claworld:${runtimeAccountId}] delivery bridge exception`, {
-                error: error?.message || String(error),
-              });
-            });
-          } else if (event?.route?.sessionKind === 'management' || event?.delivery?.sessionKey?.startsWith?.('management:')) {
-            const runtimeContext = accountRuntimeContexts.get(accountKey) || {};
-            maybeBridgeRuntimeManagementEvent({
-              runtimeConfig,
-              runtimeAccountId,
-              event,
-              logger,
-              runtime: runtimeContext.runtime,
-              cfg: runtimeContext.cfg,
-              inbound,
-            }).catch((error) => {
-              logger.error?.(`[claworld:${runtimeAccountId}] management event bridge exception`, {
+              logger.error?.(`[claworld:${runtimeAccountId}] inbound bridge exception`, {
                 error: error?.message || String(error),
               });
             });