@xfxstudio/claworld 2026.4.30-runtime-binding-fix.3 → 2026.4.30-testing.2

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

@@ -32,6 +32,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,
@@ -1807,6 +1812,230 @@ 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,
@@ -2298,12 +2527,15 @@ async function maybeBridgeRuntimeDelivery({
     UntrustedContext,
   });
 
+  let sessionStorePath = null;
+  let sessionRecord = null;
+  let sessionArtifacts = {};
   if (runtime?.channel?.session?.recordInboundSession && runtime?.channel?.session?.resolveStorePath && localAgentId) {
-    const storePath = runtime.channel.session.resolveStorePath(currentCfg.session?.store, {
+    sessionStorePath = runtime.channel.session.resolveStorePath(currentCfg.session?.store, {
       agentId: localAgentId,
     });
-    await runtime.channel.session.recordInboundSession({
-      storePath,
+    sessionRecord = await runtime.channel.session.recordInboundSession({
+      storePath: sessionStorePath,
       sessionKey: inboundCtx.SessionKey || sessionKey,
       ctx: inboundCtx,
       onRecordError: (error) => {
@@ -2316,6 +2548,46 @@ 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`, {
@@ -2323,12 +2595,15 @@ async function maybeBridgeRuntimeDelivery({
     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,
     commandAuthorized,
+    journal: journalResult?.ok === true,
   });
 
   try {
@@ -2437,6 +2712,206 @@ 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,
@@ -2479,75 +2954,6 @@ export function createClaworldChannelPlugin({
     });
   }
 
-  function resolveCachedAccountBinding({ runtimeConfig, accountId = null }) {
-    const normalizedRuntimeConfig = applyRuntimeIdentity(runtimeConfig);
-    const accountKey = resolveAccountBindingKey(normalizedRuntimeConfig, accountId || null);
-    const cachedBinding = accountBindingStates.get(accountKey)?.binding || null;
-    if (
-      !cachedBinding
-      || !cachedBinding.runtimeConfig?.serverUrl
-      || cachedBinding.runtimeConfig.serverUrl !== normalizedRuntimeConfig.serverUrl
-    ) {
-      return null;
-    }
-
-    return {
-      ...cachedBinding,
-      runtimeConfig: mergeBoundRuntimeConfig(normalizedRuntimeConfig, cachedBinding.runtimeConfig),
-      bindingSource: cachedBinding.bindingSource || 'binding_cache',
-    };
-  }
-
-  function commitRuntimeBinding({
-    context = {},
-    runtime = null,
-    runtimeSource = null,
-    accountId = null,
-    runtimeConfig = {},
-    bindingSource = 'configured_app_token',
-    relayAgent = null,
-  } = {}) {
-    const normalizedRuntimeConfig = applyRuntimeIdentity(runtimeConfig);
-    const normalizedAccountId = normalizeClaworldText(
-      normalizedRuntimeConfig.accountId,
-      normalizeClaworldText(accountId, normalizeClaworldText(context.accountId, 'default')),
-    );
-    const accountKey = resolveAccountBindingKey(normalizedRuntimeConfig, normalizedAccountId);
-    const runtimeResolution = runtimeSource
-      ? { runtime, runtimeSource }
-      : resolvePluginRuntimeCandidate(runtime || context.runtime || null);
-    const currentRuntimeContext = accountRuntimeContexts.get(accountKey)
-      || accountRuntimeContexts.get(normalizedAccountId)
-      || null;
-
-    rememberAccountBinding({
-      runtimeConfig: normalizedRuntimeConfig,
-      accountId: normalizedAccountId,
-      bindingSource,
-      relayAgent,
-    });
-
-    accountRuntimeContexts.set(accountKey, {
-      ...(currentRuntimeContext || {}),
-      runtime: currentRuntimeContext?.runtime || runtimeResolution.runtime || null,
-      runtimeSource: currentRuntimeContext?.runtimeSource || runtimeResolution.runtimeSource || null,
-      cfg: currentRuntimeContext?.cfg || context.cfg || null,
-      accountId: normalizedAccountId,
-      runtimeConfig: normalizedRuntimeConfig,
-      relayAgent: relayAgent || currentRuntimeContext?.relayAgent || null,
-      bindingSource,
-      deferredFailure: null,
-      deferredErrorMessage: null,
-    });
-
-    return {
-      accountKey,
-      accountId: normalizedAccountId,
-      runtimeConfig: normalizedRuntimeConfig,
-      bindingSource,
-    };
-  }
-
   async function ensureAccountRelayBinding({ runtimeConfig, accountId = null }) {
     const normalizedRuntimeConfig = applyRuntimeIdentity(runtimeConfig);
     const accountKey = resolveAccountBindingKey(normalizedRuntimeConfig, accountId || null);
@@ -2562,7 +2968,9 @@ export function createClaworldChannelPlugin({
       return {
         ...cachedBinding,
         runtimeConfig: mergeBoundRuntimeConfig(normalizedRuntimeConfig, cachedBinding.runtimeConfig),
-        bindingSource: cachedBinding.bindingSource || 'binding_cache',
+        bindingSource: cachedBinding.bindingSource === 'configured_app_token'
+          ? 'configured_app_token'
+          : 'binding_cache',
       };
     }
 
@@ -2683,13 +3091,8 @@ export function createClaworldChannelPlugin({
       };
     }
 
-    const backupAgentId = normalizeClaworldText(
-      backup?.agentId,
-      normalizeClaworldText(runtimeConfig?.relay?.agentId, null),
-    );
     const restoredRuntimeConfig = applyRuntimeIdentity(runtimeConfig, {
       appToken: backupToken,
-      agentId: backupAgentId,
     });
 
     try {
@@ -2697,7 +3100,6 @@ export function createClaworldChannelPlugin({
         runtime,
         accountId,
         appToken: backupToken,
-        relayAgentId: backupAgentId,
       });
     } catch (error) {
       logger.warn?.(`[claworld:${accountId || 'default'}] failed to persist restored runtime appToken`, {
@@ -2725,89 +3127,16 @@ export function createClaworldChannelPlugin({
       accountId: runtimeConfig.accountId || accountId || null,
       runtimeConfig,
       agentId: context.agentId || runtimeConfig.relay?.agentId || null,
-      bindingSource: runtimeContext?.deferredFailure
-        ? 'runtime_context_deferred'
-        : (runtimeContext?.bindingSource || 'runtime_context'),
-    };
-  }
-
-  async function resolveAccountViewRuntimeContext(context = {}) {
-    const configuredContext = resolveConfiguredRuntimeContext(context);
-    const cfg = configuredContext.cfg || {};
-    const accountId = configuredContext.accountId || null;
-    let runtimeConfig = configuredContext.runtimeConfig;
-    const runtimeResolution = resolvePluginRuntimeCandidate(
-      context.runtime || configuredContext.runtime || null,
-    );
-    let bindingSource = configuredContext.bindingSource || null;
-    let relayAgent = configuredContext.relayAgent || null;
-
-    const runtimeContext = accountRuntimeContexts.get(
-      resolveAccountBindingKey(runtimeConfig, accountId || null),
-    ) || accountRuntimeContexts.get(accountId || 'default') || null;
-    if (runtimeContext?.runtimeConfig && !runtimeContext?.deferredFailure) {
-      runtimeConfig = mergeBoundRuntimeConfig(runtimeConfig, runtimeContext.runtimeConfig);
-      bindingSource = runtimeContext.bindingSource || bindingSource || 'runtime_context';
-      relayAgent = runtimeContext.relayAgent || relayAgent;
-    }
-
-    const cachedBinding = resolveCachedAccountBinding({ runtimeConfig, accountId });
-    if (cachedBinding && resolveRuntimeAppToken(cachedBinding.runtimeConfig)) {
-      runtimeConfig = cachedBinding.runtimeConfig;
-      bindingSource = cachedBinding.bindingSource || bindingSource || 'binding_cache';
-      relayAgent = cachedBinding.relayAgent || relayAgent;
-    }
-
-    if (!resolveRuntimeAppToken(runtimeConfig)) {
-      const restoredBinding = await maybeRestoreRuntimeAppToken({
-        runtime: runtimeResolution.runtime,
-        accountId,
-        runtimeConfig,
-      });
-      if (restoredBinding.restored) {
-        runtimeConfig = restoredBinding.runtimeConfig;
-        bindingSource = 'installer_state_backup';
-        logger.info?.(`[claworld:${accountId || 'default'}] restored runtime binding from installer state`, {
-          installerStatePath: restoredBinding.installerStatePath || null,
-          relayAgentId: runtimeConfig?.relay?.agentId || null,
-        });
-        commitRuntimeBinding({
-          context: configuredContext,
-          runtime: runtimeResolution.runtime,
-          runtimeSource: runtimeResolution.runtimeSource,
-          accountId,
-          runtimeConfig,
-          bindingSource,
-          relayAgent,
-        });
-      }
-    }
-
-    if (resolveRuntimeAppToken(runtimeConfig) && (!bindingSource || bindingSource === 'runtime_context')) {
-      bindingSource = 'configured_app_token';
-    }
-
-    return {
-      ...configuredContext,
-      cfg: runtimeContext?.cfg || cfg,
-      accountId: runtimeConfig.accountId || accountId || null,
-      runtimeConfig,
-      runtime: runtimeResolution.runtime,
-      runtimeSource: runtimeResolution.runtimeSource,
-      agentId: configuredContext.agentId || runtimeConfig.relay?.agentId || null,
-      bindingSource,
-      relayAgent,
+      bindingSource: runtimeContext?.deferredFailure ? 'runtime_context_deferred' : 'runtime_context',
     };
   }
 
   async function resolveBoundRuntimeContext(context = {}) {
-    const configuredContext = await resolveAccountViewRuntimeContext(context);
+    const configuredContext = resolveConfiguredRuntimeContext(context);
     const cfg = configuredContext.cfg || {};
     const accountId = configuredContext.accountId || null;
     let runtimeConfig = configuredContext.runtimeConfig;
-    const runtimeResolution = resolvePluginRuntimeCandidate(
-      context.runtime || configuredContext.runtime || null,
-    );
+    const runtimeResolution = resolvePluginRuntimeCandidate(context.runtime || null);
     const restoredBinding = await maybeRestoreRuntimeAppToken({
       runtime: runtimeResolution.runtime,
       accountId,
@@ -2830,7 +3159,7 @@ export function createClaworldChannelPlugin({
         runtime: runtimeResolution.runtime,
         runtimeSource: runtimeResolution.runtimeSource,
         agentId: configuredContext.agentId || runtimeConfig.relay?.agentId || null,
-        bindingSource: configuredContext.bindingSource || runtimeContext.bindingSource || 'runtime_context',
+        bindingSource: 'runtime_context',
       };
     }
     const binding = await ensureAccountRelayBinding({ runtimeConfig, accountId });
@@ -3017,6 +3346,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,
           });
 
@@ -3036,6 +3366,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),
+              });
+            });
           }
         });
 
@@ -3167,7 +3512,7 @@ export function createClaworldChannelPlugin({
   }
 
   async function getRuntimePublicIdentity(context = {}) {
-    const resolvedContext = await resolveAccountViewRuntimeContext(context);
+    const resolvedContext = resolveConfiguredRuntimeContext(context);
     return fetchPublicIdentity({
       runtimeConfig: resolvedContext.runtimeConfig,
       agentId: resolvedContext.agentId || null,
@@ -3178,10 +3523,7 @@ export function createClaworldChannelPlugin({
   }
 
 async function updateRuntimePublicIdentity(context = {}) {
-    const resolvedContext = await resolveAccountViewRuntimeContext(context);
-    const runtimeResolution = resolvePluginRuntimeCandidate(
-      context.runtime || resolvedContext.runtime || null,
-    );
+    const resolvedContext = resolveConfiguredRuntimeContext(context);
     const updateResult = await updatePublicIdentity({
       runtimeConfig: resolvedContext.runtimeConfig,
       agentId: resolvedContext.agentId || null,
@@ -3222,6 +3564,7 @@ async function updateRuntimePublicIdentity(context = {}) {
     );
 
     if (shouldPersistRuntimeBinding) {
+      const runtimeResolution = resolvePluginRuntimeCandidate(context.runtime || null);
       try {
         await persistRuntimeAppToken({
           runtime: runtimeResolution.runtime,
@@ -3235,19 +3578,23 @@ async function updateRuntimePublicIdentity(context = {}) {
           error: error?.message || String(error),
         });
       }
-    }
 
-    if (resolveRuntimeAppToken(boundRuntimeConfig) && nextAgentId) {
-      commitRuntimeBinding({
-        context: resolvedContext,
-        runtime: runtimeResolution.runtime,
-        runtimeSource: runtimeResolution.runtimeSource,
+      rememberAccountBinding({
         runtimeConfig: boundRuntimeConfig,
         accountId: resolvedContext.accountId || boundRuntimeConfig.accountId || null,
-        bindingSource: runtimeActivation
-          ? 'activated_app_token'
-          : (resolvedContext.bindingSource || 'configured_app_token'),
+        bindingSource: runtimeActivation ? 'activated_app_token' : 'configured_app_token',
       });
+
+      const accountKey = resolveAccountBindingKey(boundRuntimeConfig, resolvedContext.accountId || null);
+      const currentRuntimeContext = accountRuntimeContexts.get(accountKey) || null;
+      if (currentRuntimeContext) {
+        accountRuntimeContexts.set(accountKey, {
+          ...currentRuntimeContext,
+          runtimeConfig: boundRuntimeConfig,
+          deferredFailure: null,
+          deferredErrorMessage: null,
+        });
+      }
     }
 
     const payload = updateResult && typeof updateResult === 'object' && !Array.isArray(updateResult)
@@ -3433,7 +3780,6 @@ async function generateRuntimeProfileCard(context = {}) {
     },
     helpers: {
       resolveToolRuntimeContext: resolveBoundRuntimeContext,
-      resolveToolAccountViewContext: resolveAccountViewRuntimeContext,
       pairing: {
         resolveAgentIdentity: async (context = {}) => resolveRelayAgentSummary({
           runtimeConfig: context.runtimeConfig || resolveClaworldRuntimeConfig(context.cfg || {}, context.accountId || null),