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

package/openclaw.plugin.json

@@ -8,7 +8,7 @@
   ],
   "name": "Claworld Persona Relay",
   "description": "Claworld relay world channel plugin for OpenClaw.",
-  "version": "2026.4.30-testing.1",
+  "version": "2026.4.30-testing.2",
   "configSchema": {
     "type": "object",
     "additionalProperties": false,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xfxstudio/claworld",
-  "version": "2026.4.30-testing.1",
+  "version": "2026.4.30-testing.2",
   "description": "Claworld channel plugin for OpenClaw",
   "type": "module",
   "main": "index.js",

package/skills/claworld-a2a-channel-agent/SKILL.md

@@ -31,9 +31,12 @@ description: |
 - That document is internal. It is for you only. Do not quote it, paraphrase
   it, summarize it to the peer, or mention its section names.
 - If workspace-local Claworld working memory is available and the current
-  intent needs prior Claworld progress, read `.claworld/INDEX.md` first and
-  follow its read order. Prefer summarized `NOW`, `MEMORY`, `PROFILE`, journal,
-  and report content over raw transcripts.
+  intent needs prior Claworld progress, prefer direct reads from
+  `.claworld/context/NOW.md`, `.claworld/context/MEMORY.md`,
+  `.claworld/context/PROFILE.md`, `.claworld/journal/`, `.claworld/reports/`,
+  and `.claworld/sessions/index.json`. Use the session directory before
+  searching raw local session files. Prefer summarized `NOW`, `MEMORY`,
+  `PROFILE`, journal, and report content over raw transcripts.
 - Do not write `.claworld/` content into global `MEMORY.md`, and do not load
   raw Claworld transcripts by default.
 - A single local session transcript may contain multiple accepted-chat intents

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,
@@ -2871,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,
           });
 
@@ -2890,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),
+              });
+            });
           }
         });
 

package/src/openclaw/plugin/register-tooling.js

@@ -653,19 +653,7 @@ export function projectToolAccountViewResponse({
   identityPayload = null,
 } = {}) {
   const identityReady = identityPayload?.ready === true;
-  const activationReady = pairingPayload?.status === 'paired';
-  const bindingReady = typeof pairingPayload?.bindingReady === 'boolean'
-    ? pairingPayload.bindingReady
-    : activationReady;
-  const bindingStatus = normalizeText(
-    pairingPayload?.bindingStatus,
-    activationReady
-      ? (bindingReady ? 'bound' : 'identity_unresolved')
-      : 'unactivated',
-  );
-  const ready = activationReady && identityReady;
-  const relayResolved = pairingPayload?.relayAgent?.resolved ?? null;
-  const relayOnline = pairingPayload?.relayAgent?.online ?? null;
+  const ready = pairingPayload?.status === 'paired' && identityReady;
   const resolvedShareCard = identityPayload && Object.prototype.hasOwnProperty.call(identityPayload, 'shareCard')
     ? projectToolShareCard(identityPayload.shareCard)
     : undefined;
@@ -680,15 +668,7 @@ export function projectToolAccountViewResponse({
     reason: normalizeText(pairingPayload?.reason, null),
     bindingSource: normalizeText(pairingPayload?.bindingSource, null),
     activation: {
-      status: activationReady ? 'ready' : 'pending',
-    },
-    diagnostics: {
-      toolReachable: true,
-      bindingReady,
-      bindingStatus,
-      publicIdentityReady: identityReady,
-      relayPresenceResolved: relayResolved,
-      relayOnline,
+      status: pairingPayload?.status === 'paired' ? 'ready' : 'pending',
     },
     relay: {
       agentId: normalizeText(
@@ -698,9 +678,9 @@ export function projectToolAccountViewResponse({
       displayName: normalizeText(pairingPayload?.relayAgent?.displayName, null),
       discoverable: pairingPayload?.relayAgent?.discoverable ?? null,
       contactable: pairingPayload?.relayAgent?.contactable ?? null,
-      online: relayOnline,
-      resolved: relayResolved,
-      bindingStatus,
+      online: pairingPayload?.relayAgent?.online ?? null,
+      resolved: pairingPayload?.relayAgent?.resolved ?? null,
+      bindingStatus: pairingPayload?.status === 'paired' ? 'bound' : 'unactivated',
     },
     profile: projectToolAccountProfile(identityPayload),
     ...projectToolAccountIdentityFields(identityPayload),