@xfxstudio/claworld 2026.4.30-testing.3 → 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,
@@ -32,6 +33,11 @@ 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,
@@ -1841,6 +1847,385 @@ 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,
@@ -2229,10 +2614,13 @@ 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, null)),
+    contextText ? null : resolveNormalizedText(payload.text, resolveNormalizedText(payload.body, fallbackRuntimeEventText)),
   );
   const commandText = resolveNormalizedText(payload.commandText, incomingText);
   const fromAgentId = resolveNormalizedText(metadata.fromAgentId, null);
@@ -2331,6 +2719,9 @@ 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,
@@ -2346,25 +2737,66 @@ async function maybeBridgeRuntimeInboundEvent({
     UntrustedContext,
   });
 
-  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,
+  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,
-          error: error?.message || String(error),
+          sessionArtifacts,
+          workspaceRoot,
+        })
+        : buildManagementRuntimeMaintenanceEvent(resolveRuntimeManagementEnvelope(event), {
+          localSessionKey,
+          localAgentId,
+          sessionArtifacts,
+          workspaceRoot,
         });
-      },
-    });
+      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'}`, {
@@ -2373,12 +2805,15 @@ 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) {
@@ -2491,6 +2926,199 @@ 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,
@@ -2925,6 +3553,7 @@ 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,
           });
 
@@ -2944,6 +3573,21 @@ 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),
+              });
+            });
           }
         });
 
@@ -3086,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,
@@ -3116,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) {
@@ -3132,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) {
@@ -3145,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);