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

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

@@ -1,5 +1,4 @@
 import { randomUUID } from 'node:crypto';
-import path from 'node:path';
 
 import {
   applyRuntimeIdentity,
@@ -33,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,
@@ -1847,385 +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 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
-    : {};
-  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.filePath,
-        resolveNormalizedText(normalizedRecord.path, resolveNormalizedText(nestedSession.filePath, 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,
-    }),
-  };
-}
-
-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,
@@ -2614,13 +2229,10 @@ async function maybeBridgeRuntimeInboundEvent({
   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, resolveNormalizedText(payload.body, fallbackRuntimeEventText)),
+    contextText ? null : resolveNormalizedText(payload.text, resolveNormalizedText(payload.body, null)),
   );
   const commandText = resolveNormalizedText(payload.commandText, incomingText);
   const fromAgentId = resolveNormalizedText(metadata.fromAgentId, null);
@@ -2719,9 +2331,6 @@ async function maybeBridgeRuntimeInboundEvent({
     OriginatingFrom: remoteIdentity,
     OriginatingTo: remoteIdentity,
     ChatType: isManagementSession ? 'management' : 'direct',
-    SessionType: isManagementSession ? 'management' : 'direct',
-    sessionType: isManagementSession ? 'management' : 'direct',
-    sessionKind: isManagementSession ? 'management' : 'conversation',
     SenderName: senderName,
     SenderId: remoteIdentity,
     MessageId: deliveryId,
@@ -2737,66 +2346,25 @@ async function maybeBridgeRuntimeInboundEvent({
     UntrustedContext,
   });
 
-  const {
-    sessionArtifacts,
-  } = await recordRuntimeInboundSessionArtifacts({
-    runtime,
-    currentCfg,
-    localAgentId,
-    sessionKey,
-    ctx: inboundCtx,
-    logger,
-    runtimeAccountId,
-    logLabel: isRelayDelivery ? 'delivery' : 'inbound',
-    logContext: { eventType, deliveryId },
-  });
-
-  const workspaceRoot = resolveOpenClawWorkspaceRoot({
-    sources: [
-      { agentId: localAgentId, localAgentId },
-      currentCfg,
-      runtimeConfig,
-    ],
-    config: currentCfg,
-    agentId: localAgentId,
-  });
-  let journalResult = null;
-  if (workspaceRoot) {
-    try {
-      const maintenanceEvent = isRelayDelivery
-        ? buildDeliveryRuntimeMaintenanceEvent({
-          delivery,
-          metadata,
-          payload,
-          localSessionKey,
-          localAgentId,
-          sessionArtifacts,
-          workspaceRoot,
-        })
-        : buildManagementRuntimeMaintenanceEvent(resolveRuntimeManagementEnvelope(event), {
+  if (runtime?.channel?.session?.recordInboundSession && runtime?.channel?.session?.resolveStorePath && localAgentId) {
+    const storePath = runtime.channel.session.resolveStorePath(currentCfg.session?.store, {
+      agentId: localAgentId,
+    });
+    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,
           localAgentId,
-          sessionArtifacts,
-          workspaceRoot,
+          error: error?.message || String(error),
         });
-      journalResult = await appendClaworldJournalEvent(
-        workspaceRoot,
-        maintenanceEvent,
-        {
-          trigger: isRelayDelivery ? 'delivery' : 'runtime_event',
-          rule: isRelayDelivery ? 'runtime_delivery_joined_session' : 'runtime_event_joined_session',
-        },
-      );
-    } catch (error) {
-      logger.warn?.(`[claworld:${runtimeAccountId}] inbound journal append failed`, {
-        eventType,
-        deliveryId,
-        sessionKey,
-        localSessionKey,
-        localAgentId,
-        error: error?.message || String(error),
-      });
-    }
+      },
+    });
   }
 
   logger.info?.(`[claworld:${runtimeAccountId}] ${isRelayDelivery ? 'routing delivery into runtime session' : 'routing inbound event into runtime session'}`, {
@@ -2805,15 +2373,12 @@ async function maybeBridgeRuntimeInboundEvent({
     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,
     commandAuthorized,
-    journal: journalResult?.ok === true,
   });
 
   if (isRelayDelivery && metadata.acceptanceRequired !== false) {
@@ -2926,199 +2491,6 @@ async function maybeBridgeRuntimeInboundEvent({
   };
 }
 
-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,
-  });
-
-  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: [
-      { 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,
@@ -3553,7 +2925,6 @@ 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,
           });
 
@@ -3573,21 +2944,6 @@ export function createClaworldChannelPlugin({
                 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`, {
-                error: error?.message || String(error),
-              });
-            });
           }
         });