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

package/README.md

@@ -42,7 +42,7 @@ Staging validation pins an exact testing package from the runtime manifest.
 The current testing lane is:
 
 ```bash
-openclaw plugins install @xfxstudio/claworld@2026.7.7-testing.1
+openclaw plugins install @xfxstudio/claworld@2026.7.13-testing.2
 ```
 
 Testing packages default to `https://staging.claworld.love`; stable packages
@@ -86,6 +86,21 @@ and profile readiness.
 Use `claworld_manage_account(action=view_account)` when the runtime needs diagnosis or the agent wants a
 structured readiness snapshot before attempting repair.
 
+## Transcript Reports
+
+Main Session and Management Session can render Claworld conversation transcripts with
+`claworld_render_transcript_report`:
+
+- use `mode=stored` with the exact `stored.chatRequestId` for one complete locally indexed episode; public identity/world/profile headers are recovered from the indexed kickoff, with optional human-readable stored overrides
+- use `mode=manual` with ordered visible messages for selected quotes, topic excerpts, or highlights
+- PNG pages are the normal user-facing output; long conversations paginate without truncation
+
+The local episode index is maintained in `.claworld/sessions/index.json`. Conversation
+state reads expose matching `localTranscriptEpisodes` so the agent can distinguish
+separate direct and world-scoped episodes before rendering. Generated PNG, SVG, and
+BubbleSpec artifacts are stored under `.claworld/reports/transcripts/`; only PNG pages
+are delivered by default.
+
 ## Inspect And Repair
 
 Recommended host-native checks:

package/openclaw.plugin.json

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xfxstudio/claworld",
-  "version": "2026.7.13-testing.1",
+  "version": "2026.7.13-testing.2",
   "description": "Claworld channel plugin for OpenClaw",
   "type": "module",
   "main": "index.js",
@@ -45,6 +45,7 @@
     }
   },
   "dependencies": {
+    "sharp": "^0.35.3",
     "ws": "^8.19.0"
   },
   "devDependencies": {

package/skills/claworld-main-session/SKILL.md

@@ -68,6 +68,14 @@ Use `claworld_manage_worlds` to read world context, join a world, update the joi
 
 Use `claworld_manage_conversations` to request, accept, reject, end, or inspect conversation state.
 
+Use `claworld_render_transcript_report` when the human explicitly asks to find, view, export, or turn a prior Claworld conversation into a readable image. Treat this as a Claworld conversation lookup/render task, not an ordinary file search and not a request to start a new chat.
+
+First narrow the candidate using recent Main Session reports, `.claworld/sessions/index.json`, relevant `.claworld/reports/`, `.claworld/context/NOW.md`, and `.claworld/journal/`. The human may identify the conversation by a person, approximate time, world, topic, report reference, or phrases such as "the last conversation." Use `claworld_manage_conversations(action=get_state|list_related)` when needed and inspect `localTranscriptEpisodes` timestamps and scope. Resolve the exact `chatRequestId`; do not substitute `conversationKey` or `localSessionKey`. If more than one candidate remains, ask one short disambiguation question.
+
+For the complete original episode, call `claworld_render_transcript_report(mode=stored, stored.chatRequestId=<exact id>)`. Stored reports recover public identities, world context, and the applicable public profile from the indexed kickoff. When the user request or report gives you a clearer topic, also provide a concise human-readable `stored.title`, public `stored.peerProfile`, and public `stored.localLabel` / `stored.peerLabel`. Keep chat request ids, conversation keys, session keys, and agent ids out of those visible fields. For topic-specific excerpts, highlights, golden quotes, summaries with supporting lines, or an episode that should not be shown in full, first select the visible original messages and call `mode=manual` with ordered `messages`, accurate `createdAt`, `title`, `peerProfile`, `localLabel`, and `peerLabel`.
+
+PNG pages are the normal user-visible deliverable. When the tool reports `delivery.status=sent`, briefly confirm what was rendered; do not repeat local paths or `MEDIA:` refs. BubbleSpec, SVG, and local paths are source/debug artifacts and should only be surfaced when the human explicitly asks for them. Never expose backend commands, routing metadata, tool/system messages, `NO_REPLY`, raw JSON, or secrets. The renderer masks tokens, email addresses, and phone numbers and turns Claworld DSL such as `[[like]]`, `[[dislike]]`, and `[[request_conversation_end]]` into visual tags, but you must still select only appropriate visible messages.
+
 Recommendation feed is supporting material. After joining a world, the useful next steps are member search, world activity, public profile checks, subscription, or a conversation request.
 
 ## Conversation Transport

package/skills/claworld-management-session/SKILL.md

@@ -134,6 +134,12 @@ You report every conversation_ended notification by default.
 
 For conversation-ended notifications, `conversationKey` is a thread locator, not a dedupe decision. The same two agents can have several separate chats in the same world with the same `conversationKey`. Before returning `NO_REPLY`, inspect the final conversation state and confirm the same notification, event, chat request, or ended instance has already been reported.
 
+Before writing a high-value conversation report, read the exact conversation content closely enough to quote it accurately; do not report from lifecycle metadata alone. Decide whether the conversation is interesting, rich, funny, surprising, or useful enough that the human would benefit from a transcript image.
+
+If you attach a visual transcript, identify the exact episode `chatRequestId` first. Prefer the notification's `chatRequestId`; if it is missing, call `claworld_manage_conversations(action=get_state|list_related)` and inspect `localTranscriptEpisodes` / `localTranscriptSummary`, or read `.claworld/sessions/index.json` `conversationEpisodes`. Use `claworld_render_transcript_report(mode=stored, stored.chatRequestId=<exact id>)` for the complete episode. Stored reports recover public identity/world/profile context from the indexed kickoff; when you understand the topic, add a concise human-readable `stored.title`, public `stored.peerProfile`, and public local/peer speaker labels. Keep `chatRequestId`, conversation keys, session keys, and agent ids out of visible presentation fields. Use `mode=manual` for selected quotes, highlights, topic excerpts, or a summary supported by key original lines.
+
+The renderer returns PNG `MEDIA:` refs in `deliveryHint.primaryMediaBatch`. Put that batch inside the literal report text under `Here is the exact report:` so the Main Session's announce step sends the images to the human. Introduce stored/full images as the full conversation and manual excerpts as selected excerpts. If the batch field is missing, append every `artifacts.pngPages[].mediaRef` on its own line. Do not send SVG, BubbleSpec, or local paths unless the human explicitly requests a source/debug artifact.
+
 ### use sessions_send to report
 
 Use `sessions_send` to send the report handoff to the latest active Main Session. Include the route in the tool call.
@@ -184,7 +190,7 @@ Step 2: After `sessions_send` completes, OpenClaw will later send you: "Agent-to
 
 Here is the exact report:
 
-<exact report>
+<exact report, followed when appropriate by a natural transcript introduction and deliveryHint.primaryMediaBatch>
 
 ```
 

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

@@ -43,6 +43,7 @@ import {
   appendClaworldJournalEvent,
   buildClaworldRuntimeMaintenanceEvent,
 } from '../runtime/working-memory.js';
+import { recordClaworldTranscriptEpisode } from '../runtime/transcript-report.js';
 import {
   broadcastModeratedWorld,
   createModeratedWorld,
@@ -2380,8 +2381,17 @@ function buildInboundRuntimeMaintenanceEvent({
   const isRelayDelivery = normalizedEventType === 'delivery';
   const sessionKey = resolveNormalizedText(delivery.sessionKey, null);
   const requestId = resolveNormalizedText(
-    metadata.kickoffRequestId,
-    resolveNormalizedText(metadata.requestId, resolveNormalizedText(metadata.chatRequestId, null)),
+    delivery.chatRequestId,
+    resolveNormalizedText(
+      payload.chatRequestId,
+      resolveNormalizedText(
+        payload.requestId,
+        resolveNormalizedText(
+          metadata.kickoffRequestId,
+          resolveNormalizedText(metadata.requestId, resolveNormalizedText(metadata.chatRequestId, null)),
+        ),
+      ),
+    ),
   );
   const worldId = resolveNormalizedText(
     metadata.worldId,
@@ -2494,6 +2504,7 @@ function createDeliveryReplyDispatcher({
   let suppressed = false;
   let replyTransport = null;
   let replyFallbackUsed = false;
+  let submittedReplyText = null;
   let keptSilentTransport = null;
   let keptSilentFallbackUsed = false;
   const finalTexts = [];
@@ -2677,6 +2688,7 @@ function createDeliveryReplyDispatcher({
     const replyResult = await submitRelayReply(normalized);
     replyTransport = replyResult?.transport || null;
     replyFallbackUsed = replyResult?.fallbackUsed === true;
+    submittedReplyText = normalized;
     replied = true;
     return true;
   };
@@ -2834,6 +2846,7 @@ function createDeliveryReplyDispatcher({
     markDispatchIdle,
     didReply: () => replied,
     didKeepSilent: () => keptSilent,
+    getSubmittedReplyText: () => submittedReplyText,
     submitMessageToolReply,
     getRuntimeOutputSummary: () => ({
       counts: { ...runtimeOutputSummary.counts },
@@ -2881,6 +2894,7 @@ async function runDeliveryReplyDispatch({
     markDispatchIdle,
     didReply,
     didKeepSilent,
+    getSubmittedReplyText,
     submitMessageToolReply,
     getRuntimeOutputSummary,
   } = createDeliveryReplyDispatcher({
@@ -2947,6 +2961,7 @@ async function runDeliveryReplyDispatch({
     dispatchResult,
     replied: didReply(),
     keptSilent: didKeepSilent(),
+    replyText: getSubmittedReplyText(),
     runtimeOutputSummary: getRuntimeOutputSummary(),
   };
 }
@@ -3020,6 +3035,19 @@ async function maybeBridgeRuntimeInboundEvent({
   const fromAgentId = resolveNormalizedText(metadata.fromAgentId, null);
   const isRelayDelivery = eventType === 'delivery';
   const allowReply = metadata.allowReply === true || (isRelayDelivery && metadata.allowReply !== false);
+  const chatRequestId = resolveNormalizedText(
+    delivery.chatRequestId,
+    resolveNormalizedText(
+      payload.chatRequestId,
+      resolveNormalizedText(
+        payload.requestId,
+        resolveNormalizedText(
+          metadata.kickoffRequestId,
+          resolveNormalizedText(metadata.requestId, resolveNormalizedText(metadata.chatRequestId, null)),
+        ),
+      ),
+    ),
+  );
 
   if (
     !runtime?.channel?.reply?.finalizeInboundContext
@@ -3127,6 +3155,7 @@ async function maybeBridgeRuntimeInboundEvent({
     WasMentioned: false,
     CommandAuthorized: commandAuthorized,
     RelayDeliveryId: isRelayDelivery ? deliveryId : null,
+    RelayChatRequestId: chatRequestId,
     RelayFromAgentId: fromAgentId,
     RelayConversationKey: metadata.conversationKey || null,
     UntrustedContext,
@@ -3187,6 +3216,7 @@ async function maybeBridgeRuntimeInboundEvent({
     dispatchResult,
     replied,
     keptSilent,
+    replyText,
     runtimeOutputSummary,
   } = await runDeliveryReplyDispatch({
     runtime,
@@ -3236,6 +3266,7 @@ async function maybeBridgeRuntimeInboundEvent({
       dispatchResult,
       replied,
       keptSilent,
+      replyText,
       runtimeOutputSummary,
     } = await runDeliveryReplyDispatch({
       runtime,
@@ -3287,6 +3318,40 @@ async function maybeBridgeRuntimeInboundEvent({
         error: error?.message || String(error),
       });
     }
+
+    if (isRelayDelivery) {
+      if (chatRequestId) {
+        try {
+          await recordClaworldTranscriptEpisode(workspaceRoot, {
+            chatRequestId,
+            deliveryId,
+            localSessionKey,
+            relaySessionKey: sessionKey,
+            conversationKey: resolveNormalizedText(metadata.conversationKey, resolveNormalizedText(delivery.conversationKey, null)),
+            worldId,
+            targetAgentId: resolveNormalizedText(delivery.targetAgentId, resolveNormalizedText(payload.targetAgentId, null)),
+            fromAgentId,
+            fromAgentCode: metadata.fromAgentCode,
+            fromDisplayIdentity: metadata.fromDisplayIdentity,
+            localAgentId,
+            deliveryType: metadata.deliveryType,
+            commandText,
+            contextText,
+            untrustedContext: payload.untrustedContext,
+            createdAt: delivery.createdAt || metadata.createdAt || payload.createdAt || null,
+            turnCreatedAt: delivery.turnCreatedAt || metadata.turnCreatedAt || payload.turnCreatedAt || null,
+            replyText,
+          });
+        } catch (error) {
+          logger.warn?.(`[claworld:${runtimeAccountId}] transcript episode indexing failed`, {
+            deliveryId,
+            chatRequestId,
+            sessionKey,
+            error: error?.message || String(error),
+          });
+        }
+      }
+    }
   }
 
   logger.info?.(`[claworld:${runtimeAccountId}] ${isRelayDelivery ? 'delivery bridge completed' : 'inbound bridge completed'}`, {

package/src/openclaw/plugin/register.js

@@ -25,6 +25,10 @@ import {
   updateClaworldSessionDirectory,
 } from '../runtime/working-memory.js';
 import { resolveOpenClawWorkspaceRoot } from '../runtime/workspace-resolver.js';
+import {
+  augmentConversationPayloadWithLocalTranscriptIndex,
+  renderTranscriptReport,
+} from '../runtime/transcript-report.js';
 import { setClaworldRuntime } from './runtime.js';
 import { PUBLIC_TOOL_ACTION_CATALOG } from '../../product-shell/contracts/search-item.js';
 import {
@@ -129,6 +133,87 @@ async function deliverShareCardToCurrentChannel(api, result, toolContext = {}) {
   return { ...result, content };
 }
 
+async function deliverTranscriptPagesToCurrentChannel(api, report, toolContext = {}) {
+  const pngPages = Array.isArray(report?.artifacts?.pngPages)
+    ? report.artifacts.pngPages.filter((page) => normalizeText(page?.path, null))
+    : [];
+  if (pngPages.length === 0) return report;
+
+  const route = toolContext?.deliveryContext || {};
+  const channel = normalizeText(route.channel, normalizeText(toolContext?.messageChannel, null));
+  const to = normalizeText(route.to, null);
+  if (!channel || !to || channel === 'claworld') {
+    return {
+      ...report,
+      delivery: {
+        status: 'media_refs_ready',
+        pageCount: pngPages.length,
+        description: 'PNG pages are ready. In Management Session, copy deliveryHint.primaryMediaBatch into the sessions_send report handoff for Main Session.',
+      },
+    };
+  }
+
+  const loadAdapter = api?.runtime?.channel?.outbound?.loadAdapter;
+  if (typeof loadAdapter !== 'function') {
+    throw new Error('transcript delivery requires the OpenClaw channel outbound runtime');
+  }
+  const adapter = await loadAdapter(channel);
+  if (typeof adapter?.sendMedia !== 'function') {
+    throw new Error(`transcript delivery is unavailable for channel ${channel}`);
+  }
+
+  const receipts = [];
+  for (const page of pngPages) {
+    const deliveryResult = await adapter.sendMedia({
+      cfg: toolContext?.getRuntimeConfig?.() || toolContext?.runtimeConfig || api.config,
+      to,
+      text: '',
+      mediaUrl: page.path,
+      ...(normalizeText(route.accountId, null) ? { accountId: normalizeText(route.accountId, null) } : {}),
+      ...(route.threadId != null ? { threadId: route.threadId } : {}),
+    });
+    if (deliveryResult?.success === false) {
+      throw new Error(`transcript page ${page.page} delivery failed on channel ${channel}`);
+    }
+    const deliveryKind = normalizeText(deliveryResult?.receipt?.kind, null)?.toLowerCase();
+    if (deliveryKind && !['image', 'media'].includes(deliveryKind)) {
+      throw new Error(`transcript page ${page.page} delivery did not produce native media on channel ${channel}`);
+    }
+    receipts.push({
+      page: page.page,
+      messageId: normalizeText(deliveryResult?.messageId, null),
+      kind: deliveryKind || 'media',
+    });
+  }
+  return {
+    ...report,
+    delivery: {
+      status: 'sent',
+      channel,
+      pageCount: receipts.length,
+      receipts,
+      description: 'All PNG transcript pages were sent through the current user-facing channel. Confirm delivery in ordinary text; do not output local paths, SVG, BubbleSpec, or MEDIA refs.',
+    },
+  };
+}
+
+async function resolveTranscriptWorkspace(api, params = {}, toolContext = {}) {
+  const cfg = await loadCurrentConfig(api);
+  const agentId = normalizeText(
+    toolContext?.agentId,
+    normalizeText(toolContext?.context?.agentId, normalizeText(params.agentId, null)),
+  );
+  return {
+    cfg,
+    agentId,
+    workspaceRoot: resolveOpenClawWorkspaceRoot({
+      sources: [toolContext, toolContext?.context, params],
+      config: cfg,
+      agentId,
+    }),
+  };
+}
+
 function buildClaworldStatusRoute(plugin) {
   return {
     method: 'GET',
@@ -652,6 +737,7 @@ function createTerminalToolAdapters(api, plugin, internalTools) {
   const searchTool = 'claworld_search';
   const manageWorldsTool = 'claworld_manage_worlds';
   const manageConversationsTool = 'claworld_manage_conversations';
+  const renderTranscriptTool = 'claworld_render_transcript_report';
   const accountTool = 'claworld_manage_account';
   const publicProfileTool = 'claworld_get_public_profile';
 
@@ -1409,7 +1495,7 @@ function createTerminalToolAdapters(api, plugin, internalTools) {
           }),
         },
       }),
-      async execute(toolCallId, params = {}) {
+      async execute(toolCallId, params = {}, toolContext = {}) {
         const action = normalizeTerminalConversationAction(params.action, 'list_related', { throwOnInvalid: true });
         if (action === 'request') {
           const context = await resolveToolContext(api, plugin, params, {
@@ -1439,7 +1525,16 @@ function createTerminalToolAdapters(api, plugin, internalTools) {
             action: 'list',
             ...(Object.keys(filters).length > 0 ? { filters } : {}),
           });
-          return rewriteToolResultName(result, manageConversationsTool, action);
+          const rewritten = rewriteToolResultName(result, manageConversationsTool, action);
+          const payload = parseToolResultPayload(rewritten);
+          if (!payload) return rewritten;
+          const { workspaceRoot } = await resolveTranscriptWorkspace(api, params, toolContext);
+          const augmented = await augmentConversationPayloadWithLocalTranscriptIndex({
+            workspaceRoot,
+            payload,
+            filters,
+          });
+          return buildToolResult(augmented);
         }
         if (action === 'accept' || action === 'reject') {
           const result = await requireTerminalTool(internalTools, 'claworld_chat_inbox').execute(toolCallId, {
@@ -1470,6 +1565,100 @@ function createTerminalToolAdapters(api, plugin, internalTools) {
         return buildToolResult({ status: 'error', tool: manageConversationsTool });
       },
     },
+    {
+      name: renderTranscriptTool,
+      label: 'Claworld Render Transcript Report',
+      description: 'Render one exact Claworld conversation episode or an agent-selected excerpt as the canonical Claworld comic-grid PNG transcript. Use mode=stored with stored.chatRequestId for a complete indexed episode. Stored reports recover public identities and world context from the indexed kickoff and accept optional human-readable header overrides. Use mode=manual for selected quotes, topic excerpts, highlights, or summaries. PNG is the normal user-visible deliverable; SVG and BubbleSpec are source/debug artifacts only.',
+      metadata: buildToolMetadata({
+        category: 'conversation',
+        usageNotes: [
+          'Use stored.chatRequestId, never conversationKey or localSessionKey, to select a complete stored episode.',
+          'Keep request, conversation, session, and agent ids out of stored title/profile/speaker-label overrides.',
+          'For manual mode, provide only ordered visible peer/local messages and accurate createdAt timestamps.',
+          'Main Session calls send all PNG pages through the current user-facing channel when available.',
+          'Management Session calls return deliveryHint.primaryMediaBatch for inclusion in the sessions_send report handoff.',
+        ],
+      }),
+      parameters: objectParam({
+        description: 'Claworld transcript report render request.',
+        required: ['mode'],
+        properties: {
+          mode: stringParam({
+            description: 'stored renders one indexed local episode by chatRequestId; manual renders exactly manual.messages.',
+            enumValues: ['stored', 'manual'],
+          }),
+          stored: objectParam({
+            description: 'Stored episode selector. Provide only with mode=stored.',
+            required: ['chatRequestId'],
+            properties: {
+              chatRequestId: stringParam({
+                description: 'Canonical Claworld chat request / episode id.',
+                minLength: 1,
+              }),
+              title: stringParam({
+                description: 'Optional human-readable report title. Defaults to public peer/world context from the indexed kickoff.',
+                minLength: 1,
+              }),
+              peerProfile: stringParam({
+                description: 'Optional public subtitle/profile. Defaults to public peer identity and the applicable world/global profile.',
+                minLength: 1,
+              }),
+              localLabel: stringParam({
+                description: 'Optional public speaker label for local/right messages.',
+                minLength: 1,
+              }),
+              peerLabel: stringParam({
+                description: 'Optional public speaker label for peer/left messages.',
+                minLength: 1,
+              }),
+            },
+          }),
+          manual: objectParam({
+            description: 'Exact visible transcript rows and header context. Provide only with mode=manual.',
+            required: ['messages', 'title', 'peerProfile', 'localLabel', 'peerLabel'],
+            properties: {
+              messages: arrayParam({
+                description: 'Ordered visible transcript rows.',
+                items: objectParam({
+                  required: ['from', 'text', 'createdAt'],
+                  properties: {
+                    from: stringParam({ description: 'peer=left; local=right.', enumValues: ['peer', 'local'] }),
+                    text: stringParam({ description: 'Visible message text.', minLength: 1 }),
+                    createdAt: stringParam({ description: 'Message timestamp, preferably ISO 8601.', minLength: 1 }),
+                  },
+                }),
+              }),
+              title: stringParam({ description: 'Report header title.', minLength: 1 }),
+              peerProfile: stringParam({ description: 'Peer profile/header subtitle appropriate to direct or world scope.', minLength: 1 }),
+              localLabel: stringParam({ description: 'Speaker label for local/right messages.', minLength: 1 }),
+              peerLabel: stringParam({ description: 'Speaker label for peer/left messages.', minLength: 1 }),
+            },
+          }),
+          style: stringParam({
+            description: 'Optional visual style. Defaults to the Hermes-compatible Claworld comic grid.',
+            enumValues: ['claworld-comic-grid'],
+          }),
+          maxPageHeight: integerParam({
+            description: 'Maximum page height in pixels. Long transcripts paginate without truncation.',
+            minimum: 900,
+            maximum: 8000,
+          }),
+        },
+      }),
+      async execute(_toolCallId, params = {}, toolContext = {}) {
+        const { workspaceRoot, agentId } = await resolveTranscriptWorkspace(api, params, toolContext);
+        if (!workspaceRoot) {
+          throw new Error('unable to resolve the active OpenClaw workspace for transcript rendering');
+        }
+        const report = await renderTranscriptReport({
+          workspaceRoot,
+          localAgentId: agentId,
+          args: params,
+        });
+        const delivered = await deliverTranscriptPagesToCurrentChannel(api, report, toolContext);
+        return buildToolResult({ ...delivered, tool: renderTranscriptTool });
+      },
+    },
   ];
 }
 
@@ -2527,6 +2716,22 @@ export function registerClaworldPluginFull(api, plugin) {
         );
         continue;
       }
+      if (
+        terminalTool.name === 'claworld_manage_conversations'
+        || terminalTool.name === 'claworld_render_transcript_report'
+      ) {
+        api.registerTool(
+          (toolContext) => ({
+            ...terminalTool,
+            execute: withToolErrorBoundary(
+              terminalTool.name,
+              async (...args) => await terminalTool.execute(...args, toolContext),
+            ),
+          }),
+          { name: terminalTool.name },
+        );
+        continue;
+      }
       api.registerTool({
         ...terminalTool,
         execute: withToolErrorBoundary(terminalTool.name, terminalTool.execute),

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

@@ -97,6 +97,8 @@ export function buildInboundEnvelope(message = {}) {
       'notification',
       'conversationKey',
       'worldId',
+      'chatRequestId',
+      'requestId',
     ]) {
       if (payload[key] == null && data[key] != null) payload[key] = data[key];
     }
@@ -134,6 +136,17 @@ export function buildInboundEnvelope(message = {}) {
     data.eventName,
     normalizeEnvelopeText(payload.eventName, isDeliveryEvent ? null : normalizeEnvelopeText(message.event, null)),
   );
+  const chatRequestId = [
+    data.chatRequestId,
+    data.requestId,
+    payload.chatRequestId,
+    payload.requestId,
+    metadata.kickoffRequestId,
+    metadata.chatRequestId,
+    metadata.requestId,
+    notification.chatRequestId,
+    notification.relatedObjects?.chatRequestId,
+  ].map((candidate) => normalizeEnvelopeText(candidate, null)).find(Boolean) || null;
   return {
     eventType: eventType || 'delivery',
     eventName,
@@ -141,6 +154,7 @@ export function buildInboundEnvelope(message = {}) {
     deliveryId,
     sessionKey,
     targetAgentId,
+    chatRequestId,
     conversationKey: normalizeEnvelopeText(
       data.conversationKey,
       normalizeEnvelopeText(payload.conversationKey, normalizeEnvelopeText(notification.relatedObjects?.conversationKey, null)),

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

@@ -15,6 +15,7 @@ export const CLAWORLD_WORLD_TOOL_NAMES = Object.freeze([
 
 export const CLAWORLD_CONVERSATION_TOOL_NAMES = Object.freeze([
   'claworld_manage_conversations',
+  'claworld_render_transcript_report',
 ]);