@xfxstudio/claworld 0.2.23 → 0.2.25

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

@@ -37,6 +37,12 @@ import {
   fetchOwnedWorlds,
   manageModeratedWorld,
 } from '../runtime/world-moderation-helper.js';
+import {
+  fetchWorldMembership,
+  fetchWorldMemberships,
+  leaveWorldMembership,
+  updateWorldMembershipProfile,
+} from '../runtime/world-membership-helper.js';
 import { submitFeedbackReport } from '../runtime/feedback-helper.js';
 import {
   buildWorldSelectionPrompt,
@@ -50,6 +56,9 @@ import {
 } from '../runtime/product-shell-helper.js';
 import { extractBackendErrorContext } from '../runtime/backend-error-context.js';
 import { getClaworldRuntime } from './runtime.js';
+import {
+  CLAWORLD_PLUGIN_CURRENT_VERSION,
+} from '../plugin-version.js';
 import {
   createRuntimeBoundaryError,
   normalizeRuntimeBoundaryError,
@@ -114,6 +123,101 @@ function resolveNormalizedText(value, fallback = null) {
   return normalizeClaworldText(value, fallback);
 }
 
+function isAgentScopedSessionKey(sessionKey) {
+  return /^agent:[^:]+:/i.test(String(sessionKey || ''));
+}
+
+function buildAgentScopedLocalSessionKey({ sessionKey, localAgentId } = {}) {
+  const normalizedSessionKey = resolveNormalizedText(sessionKey, null);
+  if (!normalizedSessionKey) return null;
+  if (isAgentScopedSessionKey(normalizedSessionKey)) {
+    return normalizedSessionKey;
+  }
+  const normalizedLocalAgentId = resolveNormalizedText(localAgentId, null);
+  if (!normalizedLocalAgentId) {
+    return normalizedSessionKey;
+  }
+  return `agent:${normalizedLocalAgentId}:${normalizedSessionKey}`;
+}
+
+function stripAgentScopedLocalSessionKey({ sessionKey, localAgentId } = {}) {
+  const normalizedSessionKey = resolveNormalizedText(sessionKey, null);
+  if (!normalizedSessionKey) return null;
+  const normalizedLocalAgentId = resolveNormalizedText(localAgentId, null);
+  if (!normalizedLocalAgentId) {
+    return normalizedSessionKey;
+  }
+  const prefix = `agent:${normalizedLocalAgentId}:`;
+  if (normalizedSessionKey.startsWith(prefix)) {
+    return normalizedSessionKey.slice(prefix.length) || null;
+  }
+  return normalizedSessionKey;
+}
+
+function normalizeLocalSessionKeyFields(record = null, { localAgentId = null } = {}) {
+  if (!record || typeof record !== 'object' || Array.isArray(record)) {
+    return record;
+  }
+  const nextRecord = { ...record };
+  const normalizedLocalSessionKey = buildAgentScopedLocalSessionKey({
+    sessionKey: resolveNormalizedText(record.localSessionKey, resolveNormalizedText(record.sessionKey, null)),
+    localAgentId,
+  });
+  if (normalizedLocalSessionKey) {
+    nextRecord.localSessionKey = normalizedLocalSessionKey;
+  }
+  return nextRecord;
+}
+
+function normalizeChatInboxPayloadSessionKeys(payload = null, { localAgentId = null } = {}) {
+  if (!payload || typeof payload !== 'object' || Array.isArray(payload)) {
+    return payload;
+  }
+  const nextPayload = { ...payload };
+  if (payload.filters && typeof payload.filters === 'object' && !Array.isArray(payload.filters)) {
+    const normalizedFilterLocalSessionKey = buildAgentScopedLocalSessionKey({
+      sessionKey: payload.filters.localSessionKey,
+      localAgentId,
+    });
+    nextPayload.filters = {
+      ...payload.filters,
+      ...(normalizedFilterLocalSessionKey ? { localSessionKey: normalizedFilterLocalSessionKey } : {}),
+    };
+  }
+  if (Array.isArray(payload.chats)) {
+    nextPayload.chats = payload.chats.map((chat) => normalizeLocalSessionKeyFields(chat, { localAgentId }));
+  }
+  if (payload.kickoff && typeof payload.kickoff === 'object' && !Array.isArray(payload.kickoff)) {
+    nextPayload.kickoff = normalizeLocalSessionKeyFields(payload.kickoff, { localAgentId });
+  }
+  if (payload.chat && typeof payload.chat === 'object' && !Array.isArray(payload.chat)) {
+    nextPayload.chat = normalizeLocalSessionKeyFields(payload.chat, { localAgentId });
+  }
+  return nextPayload;
+}
+
+function resolveRelaySessionKeyFromOutboundContext(outboundContext = {}) {
+  const metadata = outboundContext?.metadata && typeof outboundContext.metadata === 'object' && !Array.isArray(outboundContext.metadata)
+    ? outboundContext.metadata
+    : {};
+  return normalizeClaworldText(
+    outboundContext.relaySessionKey,
+    normalizeClaworldText(
+      outboundContext.RelaySessionKey,
+      normalizeClaworldText(
+        metadata.relaySessionKey,
+        normalizeClaworldText(
+          metadata.sessionKey,
+          normalizeClaworldText(
+            outboundContext.sessionKey,
+            normalizeClaworldText(outboundContext.SessionKey, null),
+          ),
+        ),
+      ),
+    ),
+  );
+}
+
 function normalizeClaworldInteger(value, fallback = null) {
   const normalized = Number(value);
   if (!Number.isFinite(normalized)) return fallback;
@@ -174,6 +278,20 @@ const CLAWORLD_RELAY_OPERATIONAL_NOTICE_PATTERNS = [
   /^⚠️\s*Agent failed before reply:/i,
 ];
 
+// Older/runtime-variant OpenClaw hosts may surface provider/runtime failures as
+// plain final text without setting `isError`. Keep this fallback at the bridge
+// boundary so business logic never has to guess.
+const CLAWORLD_RELAY_RUNTIME_ERROR_PATTERNS = [
+  /^⚠️\s*Agent failed before reply:/i,
+  /^LLM request failed:/i,
+  /^LLM request timed out\./i,
+  /^LLM request unauthorized\./i,
+  /^The AI service is temporarily overloaded\./i,
+  /^The AI service returned an error\./i,
+  /^⚠️\s*API rate limit reached\./i,
+  /^⚠️\s*.+\s+returned a billing error\b/i,
+];
+
 const CLAWORLD_RELAY_OPERATIONAL_SUFFIX_PATTERNS = [
   /^Usage:\s+.+\s+in\s+\/\s+.+\s+out(?:\s+·\s+est\s+.+)?$/i,
 ];
@@ -201,18 +319,21 @@ function classifyRelayContinuationText(text) {
   if (!normalized) {
     return {
       text: '',
-      operational: Boolean(String(text || '').trim()),
+      operationalNotice: Boolean(String(text || '').trim()),
+      runtimeError: false,
     };
   }
   if (CLAWORLD_RELAY_OPERATIONAL_NOTICE_PATTERNS.some((pattern) => pattern.test(normalized))) {
     return {
       text: '',
-      operational: true,
+      operationalNotice: true,
+      runtimeError: false,
     };
   }
   return {
     text: normalized,
-    operational: false,
+    operationalNotice: false,
+    runtimeError: false,
   };
 }
 
@@ -220,6 +341,45 @@ function sanitizeRelayContinuationText(text) {
   return classifyRelayContinuationText(text).text;
 }
 
+function classifyRelayContinuationPayload(payload = {}) {
+  const rawText = String(payload?.text ?? payload?.body ?? '').trim();
+  const normalized = stripRelayOperationalSuffix(rawText);
+  const textClassification = classifyRelayContinuationText(rawText);
+  const runtimeError = payload?.isError === true
+    || CLAWORLD_RELAY_RUNTIME_ERROR_PATTERNS.some((pattern) => pattern.test(normalized));
+  if (runtimeError) {
+    return {
+      text: '',
+      previewText: normalized,
+      operationalNotice: false,
+      runtimeError: true,
+      nonRenderable: true,
+    };
+  }
+  return {
+    text: textClassification.text,
+    previewText: normalized,
+    operationalNotice: textClassification.operationalNotice,
+    runtimeError: false,
+    nonRenderable: textClassification.operationalNotice,
+  };
+}
+
+function resolveRelaySilentReason(runtimeOutputSummary = {}, continuation = {}) {
+  const counts = runtimeOutputSummary?.counts || {};
+  if (Number(counts.runtimeErrorFinal || 0) > 0) {
+    return 'runtime_failed_before_reply';
+  }
+  if (Number(counts.operationalNotice || 0) > 0 && Number(counts.nonRenderableFinal || 0) === Number(counts.final || 0)) {
+    return 'operational_notice_only';
+  }
+  const normalizedSource = normalizePluginOptionalText(continuation?.source);
+  if (normalizedSource && normalizedSource !== 'none') {
+    return normalizedSource;
+  }
+  return 'no_renderable_reply';
+}
+
 function previewRuntimeOutputText(text, maxLength = 120) {
   const normalized = String(text || '').replace(/\s+/g, ' ').trim();
   if (!normalized) return '';
@@ -285,6 +445,10 @@ function buildRelayContinuationText({
   };
 }
 
+function isExactNoReplyToken(text) {
+  return String(text || '').trim() === 'NO_REPLY';
+}
+
 function resolveContinuationState(turnData = {}) {
   const continuation = turnData?.continuation;
   if (!continuation || typeof continuation !== 'object' || Array.isArray(continuation)) {
@@ -351,6 +515,7 @@ async function deliverRelayMessage({ runtimeConfig, to, text, fetchImpl, logger,
   const clientMessageId = normalizePluginOptionalText(
     outboundContext.clientMessageId || outboundContext.metadata?.clientMessageId || null
   ) || buildGeneratedClientMessageId();
+  const relaySessionKey = resolveRelaySessionKeyFromOutboundContext(outboundContext);
 
   const baseUrl = normalizeRelayHttpBaseUrl(runtimeConfig.serverUrl);
   const result = await fetchJson(fetchImpl, `${baseUrl}/v1/messages`, {
@@ -371,7 +536,7 @@ async function deliverRelayMessage({ runtimeConfig, to, text, fetchImpl, logger,
         scope: outboundContext.scope || outboundContext.metadata?.scope || null,
         conversationId: outboundContext.conversationId || outboundContext.metadata?.conversationId || null,
         threadId: outboundContext.threadId || outboundContext.metadata?.threadId || null,
-        sessionKey: outboundContext.sessionKey || outboundContext.SessionKey || null,
+        sessionKey: relaySessionKey,
       },
     }),
   });
@@ -401,7 +566,7 @@ async function deliverRelayMessage({ runtimeConfig, to, text, fetchImpl, logger,
     timestamp: Date.now(),
     meta: {
       clientMessageId,
-      sessionKey: result.body?.delivery?.sessionKey || outboundContext.sessionKey || outboundContext.SessionKey || null,
+      sessionKey: result.body?.delivery?.sessionKey || relaySessionKey,
       turnId: result.body?.turn?.turnId || null,
       conversationKey: result.body?.conversationKey || null,
       targetAgentId,
@@ -504,6 +669,7 @@ async function createChatRequest({
 async function listChatInbox({
   runtimeConfig,
   agentId,
+  localAgentId = null,
   filters = null,
   direction = null,
   fetchImpl,
@@ -511,6 +677,10 @@ async function listChatInbox({
   const normalizedFilters = filters && typeof filters === 'object' && !Array.isArray(filters)
     ? filters
     : {};
+  const relayLocalSessionKey = stripAgentScopedLocalSessionKey({
+    sessionKey: normalizedFilters.localSessionKey,
+    localAgentId,
+  });
   const baseUrl = normalizeRelayHttpBaseUrl(runtimeConfig.serverUrl);
   const path = buildRelayJsonPath('/v1/chat-requests', {
     agentId,
@@ -520,7 +690,7 @@ async function listChatInbox({
     worldId: normalizedFilters.worldId,
     chatRequestId: normalizedFilters.chatRequestId,
     conversationKey: normalizedFilters.conversationKey,
-    localSessionKey: normalizedFilters.localSessionKey,
+    localSessionKey: relayLocalSessionKey,
     counterpartyAgentId: normalizedFilters.counterpartyAgentId,
   });
   const result = await fetchJson(fetchImpl, `${baseUrl}${path}`, {
@@ -546,13 +716,14 @@ async function listChatInbox({
       },
     });
   }
-  return result.body || {};
+  return normalizeChatInboxPayloadSessionKeys(result.body || {}, { localAgentId });
 }
 
 async function acceptChatRequest({
   runtimeConfig,
   actorAgentId,
   chatRequestId,
+  localAgentId = null,
   fetchImpl,
 }) {
   const baseUrl = normalizeRelayHttpBaseUrl(runtimeConfig.serverUrl);
@@ -574,7 +745,7 @@ async function acceptChatRequest({
       context: { actorAgentId, chatRequestId },
     });
   }
-  return result.body || {};
+  return normalizeChatInboxPayloadSessionKeys(result.body || {}, { localAgentId });
 }
 
 async function rejectChatRequest({
@@ -1195,6 +1366,7 @@ function buildDeliveryInboundEnvelope({
   timestamp = null,
   deliveryId,
   sessionKey,
+  localSessionKey = null,
   worldId = null,
   conversationKey = null,
   untrustedContext = [],
@@ -1215,7 +1387,8 @@ function buildDeliveryInboundEnvelope({
     `[claworld peer ${remoteLabel}]`,
     ...(worldId ? [`[claworld world ${worldId}]`] : []),
     ...(conversationKey ? [`[claworld conversation ${conversationKey}]`] : []),
-    `[claworld session ${sessionKey}]`,
+    ...(localSessionKey && localSessionKey !== sessionKey ? [`[claworld local session ${localSessionKey}]`] : []),
+    `[claworld relay session ${sessionKey}]`,
     `[claworld delivery ${deliveryId}]`,
   ], untrustedContext);
   const envelopeTimestamp = Number.isFinite(timestamp) ? new Date(timestamp) : new Date();
@@ -1287,7 +1460,9 @@ function createDeliveryReplyDispatcher({
       reasoningEnd: 0,
       compactionStart: 0,
       compactionEnd: 0,
+      nonRenderableFinal: 0,
       operationalNotice: 0,
+      runtimeErrorFinal: 0,
     },
     previews: {
       final: [],
@@ -1296,6 +1471,7 @@ function createDeliveryReplyDispatcher({
       partial: [],
       reasoning: [],
       operationalNotice: [],
+      runtimeErrorFinal: [],
     },
     relayContinuationSource: 'none',
     relayContinuationPreview: null,
@@ -1306,14 +1482,21 @@ function createDeliveryReplyDispatcher({
     runtimeOutputSummary.counts[kind] += 1;
     const text = String(payload?.text ?? payload?.body ?? '').trim();
     if (kind === 'final') {
-      if (text) {
-        finalTexts.push(text);
-        appendRuntimeOutputPreview(runtimeOutputSummary.previews.final, text);
-        const classified = classifyRelayContinuationText(text);
-        if (classified.operational) {
-          runtimeOutputSummary.counts.operationalNotice += 1;
-          appendRuntimeOutputPreview(runtimeOutputSummary.previews.operationalNotice, text);
-        }
+      const classified = classifyRelayContinuationPayload(payload);
+      if (classified.text) {
+        finalTexts.push(classified.text);
+        appendRuntimeOutputPreview(runtimeOutputSummary.previews.final, classified.text);
+      }
+      if (classified.nonRenderable) {
+        runtimeOutputSummary.counts.nonRenderableFinal += 1;
+      }
+      if (classified.operationalNotice) {
+        runtimeOutputSummary.counts.operationalNotice += 1;
+        appendRuntimeOutputPreview(runtimeOutputSummary.previews.operationalNotice, classified.previewText || text);
+      }
+      if (classified.runtimeError) {
+        runtimeOutputSummary.counts.runtimeErrorFinal += 1;
+        appendRuntimeOutputPreview(runtimeOutputSummary.previews.runtimeErrorFinal, classified.previewText || text);
       }
       return;
     }
@@ -1346,6 +1529,30 @@ function createDeliveryReplyDispatcher({
     runtimeOutputSummary.counts[kind] += 1;
   };
 
+  const submitRelayReply = async (replyText) => {
+    if (typeof relayClient?.submitDeliveryReply !== 'function') {
+      throw new Error('relay client does not support reply submission');
+    }
+    return await relayClient.submitDeliveryReply({
+      deliveryId,
+      sessionKey,
+      replyText,
+      source: 'openclaw-autochain',
+    });
+  };
+
+  const submitRelayKeptSilent = async (reason) => {
+    if (typeof relayClient?.submitDeliveryKeptSilent !== 'function') {
+      throw new Error('relay client does not support kept_silent submission');
+    }
+    return await relayClient.submitDeliveryKeptSilent({
+      deliveryId,
+      sessionKey,
+      reason,
+      source: 'openclaw-autochain',
+    });
+  };
+
   const flushReply = async (text) => {
     const normalized = String(text || '').trim();
     if (!normalized || replied || suppressed) return false;
@@ -1353,16 +1560,9 @@ function createDeliveryReplyDispatcher({
       suppressed = true;
       return false;
     }
-    const replyResult = await relayClient.replyToDeliveryHttp({
-      deliveryId,
-      replyText: normalized,
-      source: 'openclaw-autochain',
-    });
-    if (replyResult.status < 200 || replyResult.status >= 300) {
-      throw new Error(`failed to submit relay reply: ${replyResult.status}`);
-    }
-    replyTransport = 'http';
-    replyFallbackUsed = false;
+    const replyResult = await submitRelayReply(normalized);
+    replyTransport = replyResult?.transport || null;
+    replyFallbackUsed = replyResult?.fallbackUsed === true;
     replied = true;
     return true;
   };
@@ -1373,16 +1573,11 @@ function createDeliveryReplyDispatcher({
       suppressed = true;
       return false;
     }
-    const silentResult = await relayClient.keepDeliverySilentHttp({
-      deliveryId,
-      reason: normalizePluginOptionalText(reason) || 'no_renderable_reply',
-      source: 'openclaw-autochain',
-    });
-    if (silentResult.status < 200 || silentResult.status >= 300) {
-      throw new Error(`failed to submit relay kept_silent: ${silentResult.status}`);
-    }
-    keptSilentTransport = 'http';
-    keptSilentFallbackUsed = false;
+    const silentResult = await submitRelayKeptSilent(
+      normalizePluginOptionalText(reason) || 'no_renderable_reply',
+    );
+    keptSilentTransport = silentResult?.transport || null;
+    keptSilentFallbackUsed = silentResult?.fallbackUsed === true;
     keptSilent = true;
     return true;
   };
@@ -1417,21 +1612,39 @@ function createDeliveryReplyDispatcher({
   const markDispatchIdle = async () => {
     await dispatchApi.dispatcher.waitForIdle?.();
     if (!replied && !suppressed) {
-      const continuation = buildRelayContinuationText({
+      const allowPartialFallback = (
+        runtimeOutputSummary.counts.final > 0
+        && finalTexts.length === 0
+        && blockTexts.length === 0
+        && runtimeOutputSummary.counts.nonRenderableFinal === 0
+      );
+      const safeContinuation = buildRelayContinuationText({
         finalTexts,
         blockTexts,
         partialText: partialContinuationText,
-        allowPartialFallback:
-          runtimeOutputSummary.counts.final > 0 && finalTexts.length === 0 && blockTexts.length === 0,
+        allowPartialFallback,
       });
-      runtimeOutputSummary.relayContinuationSource = continuation.source;
-      runtimeOutputSummary.relayContinuationPreview = continuation.text
-        ? previewRuntimeOutputText(continuation.text)
+      runtimeOutputSummary.relayContinuationSource = safeContinuation.source;
+      runtimeOutputSummary.relayContinuationPreview = safeContinuation.text
+        ? previewRuntimeOutputText(safeContinuation.text)
         : null;
-      if (continuation.text) {
-        await flushReply(continuation.text);
+      if (safeContinuation.text && isExactNoReplyToken(safeContinuation.text)) {
+        runtimeOutputSummary.relayContinuationSource = 'no_reply_token';
+        runtimeOutputSummary.relayContinuationPreview = 'NO_REPLY';
+        await flushKeptSilent('no_reply_token');
+      } else if (safeContinuation.text) {
+        await flushReply(safeContinuation.text);
       } else {
-        await flushKeptSilent(continuation.source);
+        const silentReason = resolveRelaySilentReason(runtimeOutputSummary, safeContinuation);
+        if (runtimeOutputSummary.counts.runtimeErrorFinal > 0) {
+          logger.warn?.(`[claworld:${runtimeAccountId}] runtime produced non-renderable error finals; returning kept_silent`, {
+            deliveryId,
+            sessionKey,
+            localAgentId,
+            runtimeOutputSummary,
+          });
+        }
+        await flushKeptSilent(silentReason);
       }
     }
     await dispatchApi.markDispatchIdle?.();
@@ -1476,13 +1689,14 @@ function createDeliveryReplyDispatcher({
         final: [...runtimeOutputSummary.previews.final],
         block: [...runtimeOutputSummary.previews.block],
         tool: [...runtimeOutputSummary.previews.tool],
-        partial: [...runtimeOutputSummary.previews.partial],
-        reasoning: [...runtimeOutputSummary.previews.reasoning],
-        operationalNotice: [...runtimeOutputSummary.previews.operationalNotice],
-      },
-      relayContinuationSource: runtimeOutputSummary.relayContinuationSource,
-      relayContinuationPreview: runtimeOutputSummary.relayContinuationPreview,
-      replyTransport,
+      partial: [...runtimeOutputSummary.previews.partial],
+      reasoning: [...runtimeOutputSummary.previews.reasoning],
+      operationalNotice: [...runtimeOutputSummary.previews.operationalNotice],
+      runtimeErrorFinal: [...runtimeOutputSummary.previews.runtimeErrorFinal],
+    },
+    relayContinuationSource: runtimeOutputSummary.relayContinuationSource,
+    relayContinuationPreview: runtimeOutputSummary.relayContinuationPreview,
+    replyTransport,
       replyFallbackUsed,
       keptSilentTransport,
       keptSilentFallbackUsed,
@@ -1623,7 +1837,24 @@ async function maybeBridgeRuntimeDelivery({
     return { skipped: true, reason: 'missing_delivery_payload' };
   }
 
-  const currentCfg = cfg || await runtime.config?.loadConfig?.() || {};
+  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,
+    relayClient,
+  });
+  const localSessionKey = buildAgentScopedLocalSessionKey({
+    sessionKey,
+    localAgentId,
+  });
   const routed = inbound?.routeInboundEvent?.(delivery, {
     sessionTarget: runtimeConfig.routing?.sessionTarget,
     fallbackTarget: runtimeConfig.routing?.fallbackTarget,
@@ -1644,6 +1875,7 @@ async function maybeBridgeRuntimeDelivery({
     timestamp: inboundTimestamp,
     deliveryId,
     sessionKey,
+    localSessionKey,
     worldId,
     conversationKey: metadata.conversationKey || null,
     untrustedContext: payload.untrustedContext,
@@ -1657,7 +1889,8 @@ async function maybeBridgeRuntimeDelivery({
     BodyForCommands,
     From: `claworld:${remoteIdentity}`,
     To: `claworld:${localIdentity}`,
-    SessionKey: sessionKey,
+    SessionKey: localSessionKey || sessionKey,
+    RelaySessionKey: sessionKey,
     AccountId: runtimeConfig.accountId,
     OriginatingChannel: 'claworld',
     OriginatingFrom: remoteIdentity,
@@ -1677,11 +1910,6 @@ async function maybeBridgeRuntimeDelivery({
     RelayFromAgentId: fromAgentId,
     UntrustedContext,
   });
-  const localAgentId = resolveBoundLocalAgentId({
-    cfg: currentCfg,
-    runtimeConfig,
-    relayClient,
-  });
 
   if (runtime?.channel?.session?.recordInboundSession && runtime?.channel?.session?.resolveStorePath && localAgentId) {
     const storePath = runtime.channel.session.resolveStorePath(currentCfg.session?.store, {
@@ -1695,6 +1923,7 @@ async function maybeBridgeRuntimeDelivery({
         logger.error?.(`[claworld:${runtimeAccountId}] failed to record inbound session`, {
           deliveryId,
           sessionKey,
+          localSessionKey,
           localAgentId,
           error: error?.message || String(error),
         });
@@ -1705,6 +1934,7 @@ async function maybeBridgeRuntimeDelivery({
   logger.info?.(`[claworld:${runtimeAccountId}] routing delivery into runtime session`, {
     deliveryId,
     sessionKey,
+    localSessionKey,
     localAgentId,
     remoteIdentity,
     routeStatus: routed?.status || null,
@@ -1727,6 +1957,7 @@ async function maybeBridgeRuntimeDelivery({
     logger.warn?.(`[claworld:${runtimeAccountId}] delivery acceptance acknowledgement failed`, {
       deliveryId,
       sessionKey,
+      localSessionKey,
       localAgentId,
       error: error?.message || String(error),
     });
@@ -1755,8 +1986,8 @@ async function maybeBridgeRuntimeDelivery({
     && metadata.allowReply !== false
     && replied !== true
     && runtimeOutputSummary.counts.final > 0
-    && runtimeOutputSummary.counts.operationalNotice > 0
-    && runtimeOutputSummary.counts.final === runtimeOutputSummary.counts.operationalNotice
+    && runtimeOutputSummary.counts.nonRenderableFinal > 0
+    && runtimeOutputSummary.counts.final === runtimeOutputSummary.counts.nonRenderableFinal
     && runtimeOutputSummary.counts.block === 0
     && runtimeOutputSummary.counts.tool === 0
     && runtimeOutputSummary.counts.partial === 0
@@ -1772,6 +2003,7 @@ async function maybeBridgeRuntimeDelivery({
     logger.warn?.(`[claworld:${runtimeAccountId}] kickoff delivery produced only operational notices; retrying dispatch once`, {
       deliveryId,
       sessionKey,
+      localSessionKey,
       localAgentId,
       runtimeOutputSummary,
     });
@@ -1798,6 +2030,7 @@ async function maybeBridgeRuntimeDelivery({
   logger.info?.(`[claworld:${runtimeAccountId}] delivery bridge completed`, {
     deliveryId,
     sessionKey,
+    localSessionKey,
     queuedFinal: Boolean(dispatchResult?.queuedFinal),
     replied,
     keptSilent,
@@ -1812,6 +2045,7 @@ async function maybeBridgeRuntimeDelivery({
     keptSilent,
     queuedFinal: Boolean(dispatchResult?.queuedFinal),
     sessionKey,
+    localSessionKey,
     routeStatus: routed?.status || null,
   };
 }
@@ -2076,6 +2310,14 @@ export function createClaworldChannelPlugin({
     };
   }
 
+  function resolveContextBoundLocalAgentId(context = {}) {
+    return resolveBoundLocalAgentId({
+      cfg: context.cfg || {},
+      runtimeConfig: context.runtimeConfig || {},
+      relayClient: relayClients.get(context.accountId || 'default') || null,
+    });
+  }
+
   function getAccountLifecycle(accountKey = 'default') {
     if (lifecycles.has(accountKey)) return lifecycles.get(accountKey);
 
@@ -2375,7 +2617,7 @@ export function createClaworldChannelPlugin({
     return {
       ok: true,
       pluginId: 'claworld',
-      version: '0.3.0',
+      version: CLAWORLD_PLUGIN_CURRENT_VERSION,
       defaultAccountId: null,
       accounts: accountSnapshots,
       relayClients: Object.fromEntries(
@@ -2524,7 +2766,7 @@ async function generateRuntimeProfileCard(context = {}) {
       docsPath: '/channels/claworld',
       docsLabel: 'claworld',
       blurb: 'Claworld relay channel backed by the Claworld backend.',
-      version: '0.3.0',
+      version: CLAWORLD_PLUGIN_CURRENT_VERSION,
       forceAccountBinding: true,
     },
     onboarding: claworldOnboardingAdapter,
@@ -2690,6 +2932,7 @@ async function generateRuntimeProfileCard(context = {}) {
           return listChatInbox({
             runtimeConfig: resolvedContext.runtimeConfig,
             agentId: resolvedContext.agentId || null,
+            localAgentId: resolveContextBoundLocalAgentId(resolvedContext),
             filters: context.filters || null,
             direction: context.direction || null,
             fetchImpl,
@@ -2701,6 +2944,7 @@ async function generateRuntimeProfileCard(context = {}) {
             runtimeConfig: resolvedContext.runtimeConfig,
             actorAgentId: resolvedContext.agentId || null,
             chatRequestId: context.chatRequestId || null,
+            localAgentId: resolveContextBoundLocalAgentId(resolvedContext),
             fetchImpl,
           });
         },
@@ -2801,6 +3045,7 @@ async function generateRuntimeProfileCard(context = {}) {
             agentId: resolvedContext.agentId || null,
             displayName: context.displayName || null,
             worldContextText: context.worldContextText || null,
+            participantContextText: context.participantContextText || null,
             enabled: typeof context.enabled === 'boolean' ? context.enabled : true,
             fetchImpl,
             logger,
@@ -2835,6 +3080,60 @@ async function generateRuntimeProfileCard(context = {}) {
           });
         },
       },
+      membership: {
+        listWorldMemberships: async (context = {}) => {
+          const resolvedContext = await resolveBoundRuntimeContext(context);
+          return fetchWorldMemberships({
+            cfg: resolvedContext.cfg || {},
+            accountId: resolvedContext.accountId || null,
+            runtimeConfig: resolvedContext.runtimeConfig || null,
+            agentId: resolvedContext.agentId || null,
+            status: context.status || null,
+            includeInactive: context.includeInactive === true,
+            includeDisabled: context.includeDisabled !== false,
+            fetchImpl,
+            logger,
+          });
+        },
+        getWorldMembership: async (context = {}) => {
+          const resolvedContext = await resolveBoundRuntimeContext(context);
+          return fetchWorldMembership({
+            cfg: resolvedContext.cfg || {},
+            accountId: resolvedContext.accountId || null,
+            runtimeConfig: resolvedContext.runtimeConfig || null,
+            agentId: resolvedContext.agentId || null,
+            worldId: context.worldId || null,
+            includeDisabled: context.includeDisabled !== false,
+            fetchImpl,
+            logger,
+          });
+        },
+        updateWorldMembershipProfile: async (context = {}) => {
+          const resolvedContext = await resolveBoundRuntimeContext(context);
+          return updateWorldMembershipProfile({
+            cfg: resolvedContext.cfg || {},
+            accountId: resolvedContext.accountId || null,
+            runtimeConfig: resolvedContext.runtimeConfig || null,
+            agentId: resolvedContext.agentId || null,
+            worldId: context.worldId || null,
+            participantContextText: context.participantContextText || null,
+            fetchImpl,
+            logger,
+          });
+        },
+        leaveWorldMembership: async (context = {}) => {
+          const resolvedContext = await resolveBoundRuntimeContext(context);
+          return leaveWorldMembership({
+            cfg: resolvedContext.cfg || {},
+            accountId: resolvedContext.accountId || null,
+            runtimeConfig: resolvedContext.runtimeConfig || null,
+            agentId: resolvedContext.agentId || null,
+            worldId: context.worldId || null,
+            fetchImpl,
+            logger,
+          });
+        },
+      },
     },
     runtime: {
       protocol,
@@ -2951,6 +3250,7 @@ async function generateRuntimeProfileCard(context = {}) {
               agentId: resolvedContext.agentId || null,
               displayName: context.displayName || null,
               worldContextText: context.worldContextText || null,
+              participantContextText: context.participantContextText || null,
               enabled: typeof context.enabled === 'boolean' ? context.enabled : true,
               fetchImpl,
               logger,
@@ -2985,6 +3285,60 @@ async function generateRuntimeProfileCard(context = {}) {
             });
           },
         },
+        membership: {
+          listWorldMemberships: async (context = {}) => {
+            const resolvedContext = await resolveBoundRuntimeContext(context);
+            return fetchWorldMemberships({
+              cfg: resolvedContext.cfg || {},
+              accountId: resolvedContext.accountId || null,
+              runtimeConfig: resolvedContext.runtimeConfig || null,
+              agentId: resolvedContext.agentId || null,
+              status: context.status || null,
+              includeInactive: context.includeInactive === true,
+              includeDisabled: context.includeDisabled !== false,
+              fetchImpl,
+              logger,
+            });
+          },
+          getWorldMembership: async (context = {}) => {
+            const resolvedContext = await resolveBoundRuntimeContext(context);
+            return fetchWorldMembership({
+              cfg: resolvedContext.cfg || {},
+              accountId: resolvedContext.accountId || null,
+              runtimeConfig: resolvedContext.runtimeConfig || null,
+              agentId: resolvedContext.agentId || null,
+              worldId: context.worldId || null,
+              includeDisabled: context.includeDisabled !== false,
+              fetchImpl,
+              logger,
+            });
+          },
+          updateWorldMembershipProfile: async (context = {}) => {
+            const resolvedContext = await resolveBoundRuntimeContext(context);
+            return updateWorldMembershipProfile({
+              cfg: resolvedContext.cfg || {},
+              accountId: resolvedContext.accountId || null,
+              runtimeConfig: resolvedContext.runtimeConfig || null,
+              agentId: resolvedContext.agentId || null,
+              worldId: context.worldId || null,
+              participantContextText: context.participantContextText || null,
+              fetchImpl,
+              logger,
+            });
+          },
+          leaveWorldMembership: async (context = {}) => {
+            const resolvedContext = await resolveBoundRuntimeContext(context);
+            return leaveWorldMembership({
+              cfg: resolvedContext.cfg || {},
+              accountId: resolvedContext.accountId || null,
+              runtimeConfig: resolvedContext.runtimeConfig || null,
+              agentId: resolvedContext.agentId || null,
+              worldId: context.worldId || null,
+              fetchImpl,
+              logger,
+            });
+          },
+        },
       },
       createRelayClient: (options = {}) => relayClientFactory({ logger, inbound, outbound, protocol, ...options }),
     },