@xfxstudio/claworld 0.2.23 → 0.2.24

package/openclaw.plugin.json

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

package/package.json

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

package/src/lib/chat-request.js

@@ -1,4 +1,5 @@
 import { createKickoffBrief } from './relay/kickoff-text.js';
+import { normalizeAcceptedChatKickoffRecord } from './relay/kickoff-progress.js';
 
 function normalizeText(value, fallback = null) {
   if (value == null) return fallback;
@@ -358,7 +359,7 @@ export function normalizeStoredChatRequest(input = {}, { defaultSource = 'chat_r
   if (acceptedByAgentId) normalized.acceptedByAgentId = acceptedByAgentId;
   const approvalGrantId = normalizeText(input.approvalGrantId, null);
   if (approvalGrantId) normalized.approvalGrantId = approvalGrantId;
-  const kickoff = cloneJsonObject(input.kickoff);
+  const kickoff = normalizeAcceptedChatKickoffRecord(cloneJsonObject(input.kickoff));
   if (kickoff) normalized.kickoff = kickoff;
 
   return normalized;

package/src/lib/relay/kickoff-progress.js

@@ -0,0 +1,162 @@
+import { normalizeOptionalText } from './shared.js';
+
+function normalizeAcceptedChatKickoffField(value, fallback = null) {
+  return normalizeOptionalText(value) || fallback;
+}
+
+export function normalizeAcceptedChatKickoffRecord(kickoff = null, { fallbackStatus = null } = {}) {
+  if (!kickoff || typeof kickoff !== 'object' || Array.isArray(kickoff)) return null;
+
+  const normalized = {
+    ...kickoff,
+  };
+
+  const normalizedStatus = normalizeAcceptedChatKickoffField(normalized.status, fallbackStatus);
+  const normalizedReason = normalizeAcceptedChatKickoffField(normalized.reason, null);
+  const normalizedDeliveredAt = normalizeAcceptedChatKickoffField(normalized.deliveredAt, null);
+  const normalizedSenderKickoffDeliveredAt = normalizeAcceptedChatKickoffField(
+    normalized.senderKickoffDeliveredAt,
+    normalizedDeliveredAt,
+  );
+  const normalizedOpenerAcceptedAt = normalizeAcceptedChatKickoffField(normalized.openerAcceptedAt, null);
+  const normalizedOpenerDeliveredAt = normalizeAcceptedChatKickoffField(normalized.openerDeliveredAt, null);
+  const normalizedLiveChatEstablishedAt = normalizeAcceptedChatKickoffField(normalized.liveChatEstablishedAt, null);
+  const normalizedTurnId = normalizeAcceptedChatKickoffField(normalized.turnId, null);
+  const normalizedDeliveryId = normalizeAcceptedChatKickoffField(normalized.deliveryId, null);
+  const normalizedConversationKey = normalizeAcceptedChatKickoffField(normalized.conversationKey, null);
+  const normalizedOpenerTurnId = normalizeAcceptedChatKickoffField(normalized.openerTurnId, null);
+  const normalizedOpenerDeliveryId = normalizeAcceptedChatKickoffField(normalized.openerDeliveryId, null);
+  const normalizedFailedAt = normalizeAcceptedChatKickoffField(normalized.failedAt, null);
+
+  if (normalizedStatus) normalized.status = normalizedStatus;
+  else delete normalized.status;
+  if (normalizedReason) normalized.reason = normalizedReason;
+  else delete normalized.reason;
+  if (normalizedDeliveredAt) normalized.deliveredAt = normalizedDeliveredAt;
+  else delete normalized.deliveredAt;
+  if (normalizedSenderKickoffDeliveredAt) normalized.senderKickoffDeliveredAt = normalizedSenderKickoffDeliveredAt;
+  else delete normalized.senderKickoffDeliveredAt;
+  if (normalizedOpenerAcceptedAt) normalized.openerAcceptedAt = normalizedOpenerAcceptedAt;
+  else delete normalized.openerAcceptedAt;
+  if (normalizedOpenerDeliveredAt) normalized.openerDeliveredAt = normalizedOpenerDeliveredAt;
+  else delete normalized.openerDeliveredAt;
+  if (normalizedLiveChatEstablishedAt) normalized.liveChatEstablishedAt = normalizedLiveChatEstablishedAt;
+  else delete normalized.liveChatEstablishedAt;
+  if (normalizedTurnId) normalized.turnId = normalizedTurnId;
+  else delete normalized.turnId;
+  if (normalizedDeliveryId) normalized.deliveryId = normalizedDeliveryId;
+  else delete normalized.deliveryId;
+  if (normalizedConversationKey) normalized.conversationKey = normalizedConversationKey;
+  else delete normalized.conversationKey;
+  if (normalizedOpenerTurnId) normalized.openerTurnId = normalizedOpenerTurnId;
+  else delete normalized.openerTurnId;
+  if (normalizedOpenerDeliveryId) normalized.openerDeliveryId = normalizedOpenerDeliveryId;
+  else delete normalized.openerDeliveryId;
+  if (normalizedFailedAt) normalized.failedAt = normalizedFailedAt;
+  else delete normalized.failedAt;
+
+  const hasEstablishedEvidence = Boolean(
+    normalized.openerDeliveredAt
+    || normalized.liveChatEstablishedAt,
+  );
+
+  if (hasEstablishedEvidence && (!normalized.status || ['queued', 'sent'].includes(normalized.status))) {
+    normalized.status = 'established';
+  }
+
+  if (normalized.status === 'established') {
+    const establishedAt = normalizeAcceptedChatKickoffField(
+      normalized.liveChatEstablishedAt,
+      normalizeAcceptedChatKickoffField(
+        normalized.openerDeliveredAt,
+        normalizeAcceptedChatKickoffField(normalized.openerAcceptedAt, null),
+      ),
+    );
+    if (!normalized.openerDeliveredAt && normalized.openerAcceptedAt) {
+      normalized.openerDeliveredAt = normalized.openerAcceptedAt;
+    }
+    if (!normalized.liveChatEstablishedAt && establishedAt) {
+      normalized.liveChatEstablishedAt = establishedAt;
+    }
+    if (String(normalized.reason || '').startsWith('queued_')) {
+      delete normalized.reason;
+    }
+  }
+
+  return normalized;
+}
+
+export async function markAcceptedChatKickoffFailureWithDeps(deps, {
+  requestId = null,
+  reason = 'accepted_chat_kickoff_failed',
+  turnId = null,
+  conversationKey = null,
+} = {}) {
+  const { store, pushToAgent } = deps;
+  const normalizedRequestId = normalizeOptionalText(requestId);
+  if (!normalizedRequestId) return null;
+  const request = store.getChatRequest(normalizedRequestId);
+  if (!request) return null;
+
+  request.kickoff = normalizeAcceptedChatKickoffRecord({
+    ...(request.kickoff && typeof request.kickoff === 'object' && !Array.isArray(request.kickoff) ? request.kickoff : {}),
+    status: 'failed',
+    reason: normalizeOptionalText(reason) || 'accepted_chat_kickoff_failed',
+    ...(normalizeOptionalText(turnId) ? { turnId: normalizeOptionalText(turnId) } : {}),
+    ...(normalizeOptionalText(conversationKey) ? { conversationKey: normalizeOptionalText(conversationKey) } : {}),
+    failedAt: store.now(),
+  });
+  if (store.markChatRequestUpdated) {
+    await store.markChatRequestUpdated();
+  }
+  await pushToAgent(request.fromAgentId, 'request.updated', request);
+  await pushToAgent(request.toAgentId, 'request.updated', request);
+  return request;
+}
+
+export async function markAcceptedChatKickoffProgressWithDeps(deps, {
+  requestId = null,
+  status = null,
+  reason = null,
+  turnId = null,
+  deliveryId = null,
+  conversationKey = null,
+  senderKickoffDeliveredAt = null,
+  openerAcceptedAt = null,
+  openerDeliveredAt = null,
+  liveChatEstablishedAt = null,
+  openerTurnId = null,
+  openerDeliveryId = null,
+} = {}) {
+  const { store, pushToAgent } = deps;
+  const normalizedRequestId = normalizeOptionalText(requestId);
+  if (!normalizedRequestId) return null;
+  const request = store.getChatRequest(normalizedRequestId);
+  if (!request) return null;
+
+  request.kickoff = normalizeAcceptedChatKickoffRecord({
+    ...(request.kickoff && typeof request.kickoff === 'object' && !Array.isArray(request.kickoff) ? request.kickoff : {}),
+    ...(normalizeOptionalText(status) ? { status: normalizeOptionalText(status) } : {}),
+    ...(normalizeOptionalText(reason) ? { reason: normalizeOptionalText(reason) } : {}),
+    ...(normalizeOptionalText(turnId) ? { turnId: normalizeOptionalText(turnId) } : {}),
+    ...(normalizeOptionalText(deliveryId) ? { deliveryId: normalizeOptionalText(deliveryId) } : {}),
+    ...(normalizeOptionalText(conversationKey) ? { conversationKey: normalizeOptionalText(conversationKey) } : {}),
+    ...(normalizeOptionalText(senderKickoffDeliveredAt)
+      ? {
+          senderKickoffDeliveredAt: normalizeOptionalText(senderKickoffDeliveredAt),
+          deliveredAt: normalizeOptionalText(senderKickoffDeliveredAt),
+        }
+      : {}),
+    ...(normalizeOptionalText(openerAcceptedAt) ? { openerAcceptedAt: normalizeOptionalText(openerAcceptedAt) } : {}),
+    ...(normalizeOptionalText(openerDeliveredAt) ? { openerDeliveredAt: normalizeOptionalText(openerDeliveredAt) } : {}),
+    ...(normalizeOptionalText(liveChatEstablishedAt) ? { liveChatEstablishedAt: normalizeOptionalText(liveChatEstablishedAt) } : {}),
+    ...(normalizeOptionalText(openerTurnId) ? { openerTurnId: normalizeOptionalText(openerTurnId) } : {}),
+    ...(normalizeOptionalText(openerDeliveryId) ? { openerDeliveryId: normalizeOptionalText(openerDeliveryId) } : {}),
+  });
+  if (store.markChatRequestUpdated) {
+    await store.markChatRequestUpdated();
+  }
+  await pushToAgent(request.fromAgentId, 'request.updated', request);
+  await pushToAgent(request.toAgentId, 'request.updated', request);
+  return request;
+}

package/src/lib/relay/kickoff-text.js

@@ -21,6 +21,10 @@ function normalizeKickoffPayload(input) {
   return cloneJsonObject(input);
 }
 
+function isPlainObject(value) {
+  return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}
+
 function formatScalar(value) {
   if (value == null) return null;
   if (typeof value === 'string') return normalizeText(value, null);
@@ -28,34 +32,201 @@ function formatScalar(value) {
   return null;
 }
 
-function formatStructuredValue(value, indent = '') {
+function indentBlock(text, prefix = '  ') {
+  const normalized = normalizeText(text, null);
+  if (!normalized) return null;
+  return normalized
+    .split('\n')
+    .map((line) => `${prefix}${line}`)
+    .join('\n');
+}
+
+function renderStructuredLines(value, depth = 0) {
   const scalar = formatScalar(value);
-  if (scalar != null) return scalar;
+  const indent = '  '.repeat(depth);
+  if (scalar != null) return [`${indent}${scalar}`];
+
   if (Array.isArray(value)) {
-    const items = value
-      .map((item) => formatStructuredValue(item, `${indent}  `))
-      .filter(Boolean);
-    if (items.length === 0) return null;
-    return items.map((item) => `${indent}- ${String(item).replace(/\n/g, `\n${indent}  `)}`).join('\n');
+    return value.flatMap((item) => {
+      const itemScalar = formatScalar(item);
+      if (itemScalar != null) return [`${indent}- ${itemScalar}`];
+      const nestedLines = renderStructuredLines(item, depth + 1);
+      if (nestedLines.length === 0) return [];
+      return [`${indent}-`, ...nestedLines];
+    });
   }
-  if (!value || typeof value !== 'object') return null;
-  const entries = Object.entries(value)
-    .map(([key, entryValue]) => {
-      const formatted = formatStructuredValue(entryValue, `${indent}  `);
-      if (!formatted) return null;
-      if (formatted.includes('\n')) {
-        return `${indent}${key}:\n${formatted}`;
-      }
-      return `${indent}${key}: ${formatted}`;
-    })
-    .filter(Boolean);
-  return entries.length > 0 ? entries.join('\n') : null;
+
+  if (!isPlainObject(value)) return [];
+
+  return Object.entries(value).flatMap(([key, entryValue]) => {
+    const entryScalar = formatScalar(entryValue);
+    if (entryScalar != null) return [`${indent}${key}: ${entryScalar}`];
+    const nestedLines = renderStructuredLines(entryValue, depth + 1);
+    if (nestedLines.length === 0) return [];
+    return [`${indent}${key}:`, ...nestedLines];
+  });
+}
+
+function formatStructuredValue(value) {
+  const lines = renderStructuredLines(value, 0);
+  return lines.length > 0 ? lines.join('\n') : null;
 }
 
 function formatStructuredSection(title, value) {
+  const normalizedTitle = normalizeText(title, null);
   const formatted = formatStructuredValue(value);
-  if (!formatted) return null;
-  return `${title}:\n${formatted}`;
+  if (!normalizedTitle || !formatted) return null;
+  return `${normalizedTitle}:\n${indentBlock(formatted)}`;
+}
+
+function createAcceptedChatKickoffContextBlock(type, {
+  owner = null,
+  audience = null,
+  scope = null,
+  title = null,
+  body = null,
+  items = null,
+} = {}) {
+  const normalizedType = normalizeText(type, null);
+  if (!normalizedType) return null;
+  const normalizedBody = normalizeText(body, null);
+  const normalizedItems = Array.isArray(items)
+    ? items.map((item) => normalizeText(item, null)).filter(Boolean)
+    : [];
+  if (!normalizedBody && normalizedItems.length === 0) return null;
+
+  return {
+    type: normalizedType,
+    ...(normalizeText(owner, null) ? { owner: normalizeText(owner, null) } : {}),
+    ...(normalizeText(audience, null) ? { audience: normalizeText(audience, null) } : {}),
+    ...(normalizeText(scope, null) ? { scope: normalizeText(scope, null) } : {}),
+    ...(normalizeText(title, null) ? { title: normalizeText(title, null) } : {}),
+    ...(normalizedBody ? { body: normalizedBody } : {}),
+    ...(normalizedItems.length > 0 ? { items: normalizedItems } : {}),
+  };
+}
+
+const ACCEPTED_CHAT_CONTEXT_BLOCK_ORDER = {
+  background_information: 10,
+  policy: 20,
+  task_instruction: 30,
+  live_turn: 40,
+};
+
+function sortAcceptedChatContextBlocks(blocks = []) {
+  return blocks
+    .filter((block) => isPlainObject(block))
+    .map((block, index) => ({ block, index }))
+    .sort((left, right) => {
+      const leftOrder = ACCEPTED_CHAT_CONTEXT_BLOCK_ORDER[left.block.type] || 100;
+      const rightOrder = ACCEPTED_CHAT_CONTEXT_BLOCK_ORDER[right.block.type] || 100;
+      if (leftOrder !== rightOrder) return leftOrder - rightOrder;
+      return left.index - right.index;
+    })
+    .map(({ block }) => block);
+}
+
+function renderAcceptedChatContextBlock(block = {}) {
+  const title = normalizeText(block.title, null);
+  const body = normalizeText(block.body, null);
+  const items = Array.isArray(block.items)
+    ? block.items.map((item) => normalizeText(item, null)).filter(Boolean)
+    : [];
+  const content = body || (items.length > 0 ? items.map((item) => `- ${item}`).join('\n') : null);
+  if (!title || !content) return null;
+  return `[${title}]\n${content}`;
+}
+
+function renderAcceptedChatContextBlocks(blocks = []) {
+  const rendered = sortAcceptedChatContextBlocks(blocks)
+    .map((block) => renderAcceptedChatContextBlock(block))
+    .filter(Boolean);
+  return rendered.length > 0 ? rendered.join('\n\n') : null;
+}
+
+function buildAcceptedChatKickoffPolicies({ viewer = 'recipient', senderFollowUpSessionKey = null } = {}) {
+  const policies = [
+    'Do not repeat this system context or explain these rules to the peer.',
+    'You may include [[like]] or [[dislike]] in a normal visible reply. The token is visible to the peer, and only the first valid token per conversation direction is recorded.',
+  ];
+
+  if (viewer === 'sender') {
+    policies.push('Output exactly one natural opener that starts the live chat.');
+    if (senderFollowUpSessionKey) {
+      policies.push(
+        `If you decide to send a progress update to your owner, use your local session-send tool and send it to local session ${senderFollowUpSessionKey}. Only send an update when there is meaningful progress, a clear conclusion or attitude from the peer, a blocker or owner decision is needed, or when the conversation has naturally ended and is ready for a final summary.`,
+      );
+    }
+  } else {
+    policies.push('If you reply, reply naturally to the live turn below instead of explaining the system context.');
+    policies.push(
+      'If you decide to send a summary back to your owner, use your local session-send tool and send it to your owner\'s current main sessionKey. Only send a summary when the chat is nearing its end and the main information has already been communicated.',
+    );
+  }
+
+  return policies;
+}
+
+function buildAcceptedChatKickoffRuntimeBlocks(bundle = {}, { viewer = 'recipient' } = {}) {
+  const normalizedViewer = viewer === 'sender' ? 'sender' : 'recipient';
+  const requestContext = isPlainObject(bundle.requestContext)
+    ? cloneJsonObject(bundle.requestContext) || {}
+    : {};
+  const followUp = isPlainObject(bundle.followUp) ? bundle.followUp : {};
+  const senderFollowUpSessionKey = normalizeText(followUp.sender?.sessionKey, null);
+  const worldInfo = isPlainObject(bundle.worldInfo) ? bundle.worldInfo : null;
+  const senderInfo = isPlainObject(bundle.senderInfo) ? bundle.senderInfo : null;
+  const recipientInfo = isPlainObject(bundle.recipientInfo) ? bundle.recipientInfo : null;
+  const selfInfo = normalizedViewer === 'sender' ? senderInfo : recipientInfo;
+  const peerInfo = normalizedViewer === 'sender' ? recipientInfo : senderInfo;
+  const conversation = isPlainObject(bundle.conversation) ? bundle.conversation : {};
+
+  const conversationFacts = {
+    ...(normalizeText(bundle.requestId, null) ? { requestId: normalizeText(bundle.requestId, null) } : {}),
+    ...(normalizeText(conversation.mode, null) ? { mode: normalizeText(conversation.mode, null) } : {}),
+    ...(Object.keys(requestContext).length > 0 ? { requestContext } : {}),
+    ...(worldInfo ? { world: worldInfo } : {}),
+  };
+  const participantFacts = {
+    ...(selfInfo ? { you: selfInfo } : {}),
+    ...(peerInfo ? { peer: peerInfo } : {}),
+  };
+
+  const backgroundBody = [
+    formatStructuredSection('Conversation Facts', conversationFacts),
+    formatStructuredSection('Participants', participantFacts),
+  ].filter(Boolean).join('\n\n');
+
+  const taskBody = normalizedViewer === 'sender'
+    ? 'Generate the first live opener for this accepted chat.'
+    : 'Treat the live turn below as the first live turn of this accepted chat, then decide whether and how to reply naturally.';
+
+  return [
+    createAcceptedChatKickoffContextBlock('background_information', {
+      owner: 'conversation',
+      audience: normalizedViewer,
+      scope: 'conversation',
+      title: 'Background Information',
+      body: backgroundBody,
+    }),
+    createAcceptedChatKickoffContextBlock('policy', {
+      owner: 'orchestration',
+      audience: normalizedViewer,
+      scope: 'kickoff_only',
+      title: 'Policies',
+      items: buildAcceptedChatKickoffPolicies({
+        viewer: normalizedViewer,
+        senderFollowUpSessionKey,
+      }),
+    }),
+    createAcceptedChatKickoffContextBlock('task_instruction', {
+      owner: 'orchestration',
+      audience: normalizedViewer,
+      scope: 'current_turn',
+      title: 'Current Task',
+      body: taskBody,
+    }),
+  ].filter(Boolean);
 }
 
 function normalizeKickoffSource(value, fallback = 'chat_request_brief') {
@@ -158,6 +329,7 @@ function buildAcceptedChatKickoffRuntimeContext(bundle = {}, { viewer = 'recipie
 
   return {
     viewer: resolvedViewer,
+    blocks: buildAcceptedChatKickoffRuntimeBlocks(bundle, { viewer: resolvedViewer }),
     text: formatAcceptedChatKickoffMessage(bundle, { viewer: resolvedViewer }),
     briefText: normalizeText(brief.text, null),
   };
@@ -184,13 +356,17 @@ export function readAcceptedChatKickoffRuntimeContext(bundle = {}, { viewer = 'r
     : null;
   if (!candidate) return null;
 
-  const text = normalizeText(candidate.text, null);
+  const blocks = Array.isArray(candidate.blocks)
+    ? sortAcceptedChatContextBlocks(candidate.blocks.map((block) => cloneJsonObject(block) || block))
+    : [];
+  const text = normalizeText(candidate.text, renderAcceptedChatContextBlocks(blocks));
   if (!text) return null;
 
   return {
     viewer: resolvedViewer,
     text,
     briefText: normalizeText(candidate.briefText, normalizeText(brief.text, null)),
+    ...(blocks.length > 0 ? { blocks } : {}),
   };
 }
 
@@ -219,49 +395,8 @@ export function createAcceptedChatKickoffRuntimeContextForAgent(bundle = {}, {
 }
 
 export function formatAcceptedChatKickoffMessage(bundle = {}, { viewer = 'recipient' } = {}) {
-  const normalizedViewer = viewer === 'sender' ? 'sender' : 'recipient';
-  const requestContext = bundle.requestContext && typeof bundle.requestContext === 'object' && !Array.isArray(bundle.requestContext)
-    ? cloneJsonObject(bundle.requestContext) || {}
-    : {};
-  const followUp = bundle.followUp && typeof bundle.followUp === 'object' && !Array.isArray(bundle.followUp)
-    ? bundle.followUp
-    : {};
-  const senderFollowUpSessionKey = normalizeText(followUp.sender?.sessionKey, null);
-  const worldInfo = bundle.worldInfo && typeof bundle.worldInfo === 'object' && !Array.isArray(bundle.worldInfo)
-    ? bundle.worldInfo
-    : null;
-  const senderInfo = bundle.senderInfo && typeof bundle.senderInfo === 'object' && !Array.isArray(bundle.senderInfo)
-    ? bundle.senderInfo
-    : null;
-  const recipientInfo = bundle.recipientInfo && typeof bundle.recipientInfo === 'object' && !Array.isArray(bundle.recipientInfo)
-    ? bundle.recipientInfo
-    : null;
-  const selfInfo = normalizedViewer === 'sender' ? senderInfo : recipientInfo;
-  const peerInfo = normalizedViewer === 'sender' ? recipientInfo : senderInfo;
-  const viewerInstruction = normalizedViewer === 'recipient'
-    ? 'Use this accepted-chat kickoff context to interpret the sender opener as the first live turn of the accepted chat episode. Decide whether and how to reply. Do not echo the bundle verbatim to the peer.'
-    : 'Use this accepted-chat kickoff bundle to craft the first live opener to the recipient. Do not echo the bundle verbatim to the peer.';
-
-  const blocks = [
-    normalizedViewer === 'recipient'
-      ? 'Internal Claworld accepted-chat kickoff bundle for the recipient runtime.'
-      : 'Internal Claworld accepted-chat kickoff bundle for the sender runtime.',
-    viewerInstruction,
-    normalizeText(bundle.requestId, null) ? `Accepted episode: ${bundle.requestId}` : null,
-    formatStructuredSection('主人想让你做的事情 / 请求上下文', requestContext),
-    normalizedViewer === 'sender' && senderFollowUpSessionKey
-      ? `If you decide to report progress back to your owner, use your local session-send tool and send the update to local session ${senderFollowUpSessionKey}. Do not report every turn. Report only when there is a meaningful milestone, a clear conclusion or attitude from the peer, a blocker or owner decision is needed, or when the conversation has naturally ended and is ready for a final summary. Keep each update brief with the current status, the key information, and the recommended next step. If no update is needed yet, you may wait.`
-      : normalizedViewer === 'recipient'
-        ? 'If you decide to report back to your owner, use your local session-send tool and send the summary to the sessionKey your owner is currently using as their main session. Do this only when the chat is nearing its end and the main information has already been communicated. Do not report every turn. Keep each update brief with the current status, the key information already confirmed, and any final outcome or recommended next step. If the conversation is still in progress or key details are still being clarified, wait before reporting back.'
-        : null,
-    formatStructuredSection('世界信息', worldInfo),
-    formatStructuredSection('我方信息', selfInfo),
-    formatStructuredSection('对方信息', peerInfo),
-    '在正常回复中，你可以附带 [[like]] 或 [[dislike]] 来表达你对这段 conversation 的反馈。这个 token 对对方可见，系统只会按当前 conversation 和方向记录第一次有效反馈。',
-    normalizedViewer === 'sender'
-      ? '请你现在直接输出一条自然的开场白。不要解释规则，不要复述这些说明。'
-      : '请把对方刚发来的 opener 视为这段对话的第一条 live turn，并决定是否以及如何直接回复。不要解释规则，不要复述这些说明。',
-  ].filter(Boolean);
-
-  return blocks.join('\n\n');
+  const resolvedViewer = viewer === 'sender' ? 'sender' : 'recipient';
+  return renderAcceptedChatContextBlocks(
+    buildAcceptedChatKickoffRuntimeBlocks(bundle, { viewer: resolvedViewer }),
+  );
 }

package/src/lib/relay/shared.js

@@ -0,0 +1,30 @@
+export function normalizePositiveInteger(value, fallback) {
+  const normalized = Number(value);
+  if (!Number.isFinite(normalized) || normalized <= 0) return fallback;
+  return Math.floor(normalized);
+}
+
+export function normalizeOptionalText(value) {
+  if (typeof value !== 'string') return null;
+  const normalized = value.trim();
+  return normalized || null;
+}
+
+export function cloneJsonObject(value) {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) return null;
+  try {
+    const cloned = JSON.parse(JSON.stringify(value));
+    if (!cloned || typeof cloned !== 'object' || Array.isArray(cloned)) return null;
+    return cloned;
+  } catch {
+    return null;
+  }
+}
+
+export function buildFailureBody(reason, extras = {}) {
+  return {
+    error: reason,
+    reason,
+    ...extras,
+  };
+}

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

@@ -1,4 +1,5 @@
 import { randomUUID } from 'node:crypto';
+import claworldPackageJson from '../../../package.json' with { type: 'json' };
 
 import {
   applyRuntimeIdentity,
@@ -57,6 +58,8 @@ import {
 } from '../../lib/runtime-errors.js';
 import { PUBLIC_IDENTITY_STATUS } from '../../lib/public-identity.js';
 
+const CLAWORLD_PLUGIN_VERSION = claworldPackageJson.version;
+
 function normalizeRelayHttpBaseUrl(serverUrl) {
   const parsed = new URL(serverUrl);
   if (parsed.protocol === 'ws:') parsed.protocol = 'http:';
@@ -114,6 +117,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 +272,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 +313,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 +335,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 '';
@@ -351,6 +505,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 +526,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 +556,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 +659,7 @@ async function createChatRequest({
 async function listChatInbox({
   runtimeConfig,
   agentId,
+  localAgentId = null,
   filters = null,
   direction = null,
   fetchImpl,
@@ -511,6 +667,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 +680,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 +706,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 +735,7 @@ async function acceptChatRequest({
       context: { actorAgentId, chatRequestId },
     });
   }
-  return result.body || {};
+  return normalizeChatInboxPayloadSessionKeys(result.body || {}, { localAgentId });
 }
 
 async function rejectChatRequest({
@@ -1195,6 +1356,7 @@ function buildDeliveryInboundEnvelope({
   timestamp = null,
   deliveryId,
   sessionKey,
+  localSessionKey = null,
   worldId = null,
   conversationKey = null,
   untrustedContext = [],
@@ -1215,7 +1377,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 +1450,9 @@ function createDeliveryReplyDispatcher({
       reasoningEnd: 0,
       compactionStart: 0,
       compactionEnd: 0,
+      nonRenderableFinal: 0,
       operationalNotice: 0,
+      runtimeErrorFinal: 0,
     },
     previews: {
       final: [],
@@ -1296,6 +1461,7 @@ function createDeliveryReplyDispatcher({
       partial: [],
       reasoning: [],
       operationalNotice: [],
+      runtimeErrorFinal: [],
     },
     relayContinuationSource: 'none',
     relayContinuationPreview: null,
@@ -1306,14 +1472,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 +1519,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 +1550,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 +1563,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 +1602,35 @@ 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) {
+        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 +1675,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 +1823,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 +1861,7 @@ async function maybeBridgeRuntimeDelivery({
     timestamp: inboundTimestamp,
     deliveryId,
     sessionKey,
+    localSessionKey,
     worldId,
     conversationKey: metadata.conversationKey || null,
     untrustedContext: payload.untrustedContext,
@@ -1657,7 +1875,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 +1896,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 +1909,7 @@ async function maybeBridgeRuntimeDelivery({
         logger.error?.(`[claworld:${runtimeAccountId}] failed to record inbound session`, {
           deliveryId,
           sessionKey,
+          localSessionKey,
           localAgentId,
           error: error?.message || String(error),
         });
@@ -1705,6 +1920,7 @@ async function maybeBridgeRuntimeDelivery({
   logger.info?.(`[claworld:${runtimeAccountId}] routing delivery into runtime session`, {
     deliveryId,
     sessionKey,
+    localSessionKey,
     localAgentId,
     remoteIdentity,
     routeStatus: routed?.status || null,
@@ -1727,6 +1943,7 @@ async function maybeBridgeRuntimeDelivery({
     logger.warn?.(`[claworld:${runtimeAccountId}] delivery acceptance acknowledgement failed`, {
       deliveryId,
       sessionKey,
+      localSessionKey,
       localAgentId,
       error: error?.message || String(error),
     });
@@ -1755,8 +1972,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 +1989,7 @@ async function maybeBridgeRuntimeDelivery({
     logger.warn?.(`[claworld:${runtimeAccountId}] kickoff delivery produced only operational notices; retrying dispatch once`, {
       deliveryId,
       sessionKey,
+      localSessionKey,
       localAgentId,
       runtimeOutputSummary,
     });
@@ -1798,6 +2016,7 @@ async function maybeBridgeRuntimeDelivery({
   logger.info?.(`[claworld:${runtimeAccountId}] delivery bridge completed`, {
     deliveryId,
     sessionKey,
+    localSessionKey,
     queuedFinal: Boolean(dispatchResult?.queuedFinal),
     replied,
     keptSilent,
@@ -1812,6 +2031,7 @@ async function maybeBridgeRuntimeDelivery({
     keptSilent,
     queuedFinal: Boolean(dispatchResult?.queuedFinal),
     sessionKey,
+    localSessionKey,
     routeStatus: routed?.status || null,
   };
 }
@@ -2076,6 +2296,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 +2603,7 @@ export function createClaworldChannelPlugin({
     return {
       ok: true,
       pluginId: 'claworld',
-      version: '0.3.0',
+      version: CLAWORLD_PLUGIN_VERSION,
       defaultAccountId: null,
       accounts: accountSnapshots,
       relayClients: Object.fromEntries(
@@ -2524,7 +2752,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_VERSION,
       forceAccountBinding: true,
     },
     onboarding: claworldOnboardingAdapter,
@@ -2690,6 +2918,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 +2930,7 @@ async function generateRuntimeProfileCard(context = {}) {
             runtimeConfig: resolvedContext.runtimeConfig,
             actorAgentId: resolvedContext.agentId || null,
             chatRequestId: context.chatRequestId || null,
+            localAgentId: resolveContextBoundLocalAgentId(resolvedContext),
             fetchImpl,
           });
         },

package/src/openclaw/plugin/relay-client.js

@@ -486,7 +486,7 @@ export class ClaworldRelayClient extends EventEmitter {
     config,
     agentId,
     credential = null,
-    clientVersion = 'claworld-plugin/0.2.23',
+    clientVersion = 'claworld-plugin/0.2.24',
     sessionTarget,
     fallbackTarget,
   } = {}) {
@@ -1039,6 +1039,24 @@ export class ClaworldRelayClient extends EventEmitter {
     }
   }
 
+  async submitDeliveryReply({
+    deliveryId,
+    sessionKey,
+    replyText,
+    source = 'subagent',
+    timeoutMs = DEFAULT_REPLY_ACK_TIMEOUT_MS,
+    httpFallback = true,
+  } = {}) {
+    return await this.sendReplyAndWaitForAck({
+      deliveryId,
+      sessionKey,
+      replyText,
+      source,
+      timeoutMs,
+      httpFallback,
+    });
+  }
+
   async sendAcceptedAndWaitForAck({
     deliveryId,
     sessionKey,
@@ -1222,6 +1240,24 @@ export class ClaworldRelayClient extends EventEmitter {
     }
   }
 
+  async submitDeliveryKeptSilent({
+    deliveryId,
+    sessionKey,
+    reason = null,
+    source = 'openclaw-autochain',
+    timeoutMs = DEFAULT_REPLY_ACK_TIMEOUT_MS,
+    httpFallback = true,
+  } = {}) {
+    return await this.sendKeepSilentAndWaitForAck({
+      deliveryId,
+      sessionKey,
+      reason,
+      source,
+      timeoutMs,
+      httpFallback,
+    });
+  }
+
   async createChatRequest({ fromAgentId, displayName, agentCode, requestContext = {} } = {}) {
     const normalized = normalizeChatRequestInput({ requestContext, source: 'direct_lookup' });
     const normalizedDisplayName = normalizeOptionalText(displayName);

package/src/openclaw/runtime/tool-contracts.js

@@ -1,3 +1,5 @@
+import { normalizeAcceptedChatKickoffRecord } from '../../lib/relay/kickoff-progress.js';
+
 function normalizeText(value, fallback = null) {
   if (value == null) return fallback;
   const normalized = String(value).trim();
@@ -437,20 +439,27 @@ function normalizeConversationScopeDetails(input = {}) {
 }
 
 function projectChatRequestKickoff(kickoff = {}) {
-  if (!kickoff || typeof kickoff !== 'object') return null;
+  const normalizedKickoff = normalizeAcceptedChatKickoffRecord(kickoff, { fallbackStatus: 'skipped' });
+  if (!normalizedKickoff) return null;
   return {
-    status: normalizeText(kickoff.status, 'skipped'),
-    deliveredAt: normalizeText(kickoff.deliveredAt, null),
-    senderKickoffDeliveredAt: normalizeText(kickoff.senderKickoffDeliveredAt, normalizeText(kickoff.deliveredAt, null)),
-    openerAcceptedAt: normalizeText(kickoff.openerAcceptedAt, null),
-    openerDeliveredAt: normalizeText(kickoff.openerDeliveredAt, null),
-    liveChatEstablishedAt: normalizeText(kickoff.liveChatEstablishedAt, null),
-    conversationKey: normalizeText(kickoff.conversationKey, null),
-    localSessionKey: normalizeText(kickoff.localSessionKey, normalizeText(kickoff.sessionKey, null)),
-    turnId: normalizeText(kickoff.turnId, null),
-    deliveryId: normalizeText(kickoff.deliveryId, null),
-    created: typeof kickoff.created === 'boolean' ? kickoff.created : null,
-    reason: normalizeText(kickoff.reason, null),
+    status: normalizeText(normalizedKickoff.status, 'skipped'),
+    deliveredAt: normalizeText(normalizedKickoff.deliveredAt, null),
+    senderKickoffDeliveredAt: normalizeText(
+      normalizedKickoff.senderKickoffDeliveredAt,
+      normalizeText(normalizedKickoff.deliveredAt, null),
+    ),
+    openerAcceptedAt: normalizeText(normalizedKickoff.openerAcceptedAt, null),
+    openerDeliveredAt: normalizeText(normalizedKickoff.openerDeliveredAt, null),
+    liveChatEstablishedAt: normalizeText(normalizedKickoff.liveChatEstablishedAt, null),
+    conversationKey: normalizeText(normalizedKickoff.conversationKey, null),
+    localSessionKey: normalizeText(
+      normalizedKickoff.localSessionKey,
+      normalizeText(normalizedKickoff.sessionKey, null),
+    ),
+    turnId: normalizeText(normalizedKickoff.turnId, null),
+    deliveryId: normalizeText(normalizedKickoff.deliveryId, null),
+    created: typeof normalizedKickoff.created === 'boolean' ? normalizedKickoff.created : null,
+    reason: normalizeText(normalizedKickoff.reason, null),
   };
 }