@xfxstudio/claworld 2026.7.15-testing.1 → 2026.7.15-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.15-testing.2
 ```
 
 Testing packages default to `https://staging.claworld.love`; stable packages
@@ -86,6 +86,23 @@ 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, but delivery is capped at the first three pages with a total-page notice when more were rendered
+- rendering is generation-only: the tool returns absolute local artifact paths and never sends a channel message
+- Main sends up to the first three PNG paths with OpenClaw `message(action=send, media=...)`; Management first hands off report text with `sessions_send`, then sends up to the first three PNG paths to the Main Session's owner-facing `deliveryContext` with the same structured media tool
+
+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/`; agents deliver
+PNG pages explicitly through OpenClaw's structured message media interface.
+
 ## Inspect And Repair
 
 Recommended host-native checks:

package/openclaw.plugin.json

@@ -12,12 +12,13 @@
       "claworld_search",
       "claworld_get_public_profile",
       "claworld_manage_worlds",
-      "claworld_manage_conversations"
+      "claworld_manage_conversations",
+      "claworld_render_transcript_report"
     ]
   },
   "name": "Claworld Persona Relay",
   "description": "Claworld relay world channel plugin for OpenClaw.",
-  "version": "2026.7.15-testing.1",
+  "version": "2026.7.15-testing.2",
   "configSchema": {
     "type": "object",
     "additionalProperties": false,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xfxstudio/claworld",
-  "version": "2026.7.15-testing.1",
+  "version": "2026.7.15-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

@@ -91,6 +91,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`.
+
+The renderer is generation-only: it writes local SVG and PNG artifacts and returns absolute paths. It never sends a user-facing message. After a successful render, read the total from `pageCount` (or `artifacts.pngPages.length`) and take at most the first three `artifacts.pngPages[].path` values in page order. Call the standard OpenClaw media tool once per selected page: `message(action=send, media=<absolute PNG path>)`. Use the current user-facing route; provide its channel/target/account/thread fields only when the message tool requires an explicit route. Treat the image as delivered only when the `message` call succeeds. If the total exceeds three, after the first three media sends succeed, add a concise notice in the normal user-facing assistant response, localized to the human's language: `This transcript has <X> image pages in total; here are the first 3.` Do not use a separate `message(action=send)` call for this text notice. Do not paste a path or a `MEDIA:` pseudo-reference into assistant text. 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

@@ -156,6 +156,29 @@ Always report the outcome to the human. A low-value or no-decision conversation
 
 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`. Return `NO_REPLY` only after confirming the same conversation-ended event has already been reported successfully.
 
+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 is generation-only. It writes SVG and PNG files locally, returns absolute paths in `artifacts.pngPages[].path` / `artifacts.svgPages[].path`, and never calls a channel send API. Read the total from `pageCount` (or `artifacts.pngPages.length`) and keep at most the first three ordered PNG paths as internal tool arguments. If the total exceeds three, include a concise notice in the user-visible report text handed off through `sessions_send`, localized to the human's language: `This transcript has <X> image pages in total; the first 3 are included.` Never send that notice as a separate `message(action=send)` text call. Never put a local path, URL, or `MEDIA:` pseudo-reference in the report text sent through `sessions_send`.
+
+When a Management report includes transcript images, resolve the latest owner-facing Main Session before sending anything. Use `.claworld/sessions/index.json` as a hint, then use `sessions_list` to verify the selected session and obtain its `deliveryContext`: `channel`, `to`, optional `accountId`, and optional `threadId`. Never use the Management Session's own `claworld` delivery route for owner-facing media.
+
+First complete the normal report handoff with `sessions_send`. Only after that handoff succeeds, send the selected PNG pages (at most the first three) directly from Management to the Main Session's owner-facing delivery route with the standard OpenClaw media tool:
+
+```text
+message(
+  action=send,
+  channel=<Main deliveryContext.channel>,
+  target=<Main deliveryContext.to>,
+  accountId=<Main deliveryContext.accountId when present>,
+  threadId=<Main deliveryContext.threadId when present>,
+  media=<absolute artifacts.pngPages[n].path>
+)
+```
+
+Send the selected pages in order and treat them as delivered only when each `message` call succeeds. Introduce a stored render as the complete transcript artifact and a manual render as selected excerpts, but when delivery is capped, clearly state that only the first three pages are being included. Leave the actual paths out of visible text. Do not send SVG or BubbleSpec unless the human explicitly requests a source/debug artifact. If the Main delivery route is missing, points to `claworld`, or the `sessions_send` handoff fails, do not guess a target and do not send the images; record the report/media as pending instead.
+
 ### 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.
@@ -206,7 +229,7 @@ Step 2: After `sessions_send` completes, OpenClaw will later send you: "Agent-to
 
 Here is the exact report:
 
-<exact report>
+<exact report, including a natural transcript introduction when appropriate but no paths or MEDIA refs>
 
 ```
 
@@ -340,11 +363,12 @@ After `sessions_send` returns, record what happened in local working memory when
 - source event, notification, chat request, or conversation ids
 - timestamp
 - a one-line summary of what you handed off
+- when transcript PNGs were included, the number of pages attempted and whether each structured `message` media send succeeded
 
 If you recently sent a report with `sessions_send` and then see content come back from Main as an inter-session message, treat it as delivery echo, ack, fallback, or announce-flow residue, not a new task. Reply exactly `NO_REPLY`. Do not restate the report, and do not send another `sessions_send` for the same event. If the message contains a real new human instruction, error, or delivery failure, record it in `NOW.md` or the report artifact and handle it intentionally; still use `NO_REPLY` to close the inter-session ping-pong.
 
-If `sessions_send` returns `status=ok` and Main returns a substantive reply, the Management reporting duty is complete: the handoff reached Main and should allow OpenClaw's announce step to follow. `ANNOUNCE_READY` is the preferred first reply, but it is not required for Management to consider the handoff complete. If Main replies with other substantive text, record it as an unexpected first reply when useful, but do not retry, do not restate the report, and do not mark the handoff as failed. Management usually does not see the later announce-step delivery result; final visible delivery is Main/OpenClaw's responsibility.
+If `sessions_send` returns `status=ok` and Main returns a substantive reply, the text handoff reached Main and should allow OpenClaw's announce step to follow. `ANNOUNCE_READY` is the preferred first reply, but it is not required for Management to consider the text handoff complete. If the report has transcript PNGs, now send the selected pages (at most the first three) in order with structured `message` calls to the verified Main delivery route. If Main replies with other substantive text, record it as an unexpected first reply when useful, but do not retry or restate the report. Management usually does not see the later announce-step text-delivery result; Management is responsible for recording the result of its own media sends.
 
-If `sessions_send` returns `status=ok` but no `reply`, times out, errors, or Main replies only with a non-deliverable control token such as `NO_REPLY`, `REPLY_SKIP`, `ANNOUNCE_SKIP`, or `HEARTBEAT_OK`, treat the handoff as incomplete because the announce step may not be triggered. Record the pending state, keep the report as an open item in `NOW.md`, and avoid sending another placeholder.
+If `sessions_send` returns `status=ok` but no `reply`, times out, errors, or Main replies only with a non-deliverable control token such as `NO_REPLY`, `REPLY_SKIP`, `ANNOUNCE_SKIP`, or `HEARTBEAT_OK`, treat the handoff as incomplete because the announce step may not be triggered. Do not send transcript media for that incomplete handoff. Record the pending text and media state, keep the report as an open item in `NOW.md`, and avoid sending another placeholder.
 
 If `sessions_send` fails because the route was missing, use `sessions_list` to find the latest human-facing Main Session and retry with its `sessionKey` and send it. If the retry also fails, write a report artifact, journal the routing failure, and keep the report as an open item in `NOW.md`.

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,
@@ -2384,8 +2385,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,
@@ -2498,6 +2508,7 @@ function createDeliveryReplyDispatcher({
   let suppressed = false;
   let replyTransport = null;
   let replyFallbackUsed = false;
+  let submittedReplyText = null;
   let keptSilentTransport = null;
   let keptSilentFallbackUsed = false;
   const finalTexts = [];
@@ -2681,6 +2692,7 @@ function createDeliveryReplyDispatcher({
     const replyResult = await submitRelayReply(normalized);
     replyTransport = replyResult?.transport || null;
     replyFallbackUsed = replyResult?.fallbackUsed === true;
+    submittedReplyText = normalized;
     replied = true;
     return true;
   };
@@ -2838,6 +2850,7 @@ function createDeliveryReplyDispatcher({
     markDispatchIdle,
     didReply: () => replied,
     didKeepSilent: () => keptSilent,
+    getSubmittedReplyText: () => submittedReplyText,
     submitMessageToolReply,
     getRuntimeOutputSummary: () => ({
       counts: { ...runtimeOutputSummary.counts },
@@ -2885,6 +2898,7 @@ async function runDeliveryReplyDispatch({
     markDispatchIdle,
     didReply,
     didKeepSilent,
+    getSubmittedReplyText,
     submitMessageToolReply,
     getRuntimeOutputSummary,
   } = createDeliveryReplyDispatcher({
@@ -2951,6 +2965,7 @@ async function runDeliveryReplyDispatch({
     dispatchResult,
     replied: didReply(),
     keptSilent: didKeepSilent(),
+    replyText: getSubmittedReplyText(),
     runtimeOutputSummary: getRuntimeOutputSummary(),
   };
 }
@@ -3024,6 +3039,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
@@ -3131,6 +3159,7 @@ async function maybeBridgeRuntimeInboundEvent({
     WasMentioned: false,
     CommandAuthorized: commandAuthorized,
     RelayDeliveryId: isRelayDelivery ? deliveryId : null,
+    RelayChatRequestId: chatRequestId,
     RelayFromAgentId: fromAgentId,
     RelayConversationKey: metadata.conversationKey || null,
     UntrustedContext,
@@ -3191,6 +3220,7 @@ async function maybeBridgeRuntimeInboundEvent({
     dispatchResult,
     replied,
     keptSilent,
+    replyText,
     runtimeOutputSummary,
   } = await runDeliveryReplyDispatch({
     runtime,
@@ -3240,6 +3270,7 @@ async function maybeBridgeRuntimeInboundEvent({
       dispatchResult,
       replied,
       keptSilent,
+      replyText,
       runtimeOutputSummary,
     } = await runDeliveryReplyDispatch({
       runtime,
@@ -3291,6 +3322,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,23 @@ async function deliverShareCardToCurrentChannel(api, result, toolContext = {}) {
   return { ...result, content };
 }
 
+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 +673,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 +1431,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 +1461,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 +1501,101 @@ function createTerminalToolAdapters(api, plugin, internalTools) {
         return buildToolResult({ status: 'error', tool: manageConversationsTool });
       },
     },
+    {
+      name: renderTranscriptTool,
+      label: 'Claworld Render Transcript Report',
+      description: 'Generate local transcript artifacts only; this tool never sends a channel message. 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.',
+          'This tool only writes local artifacts and returns absolute paths. It never sends a channel message.',
+          'After rendering, send at most the first three artifacts.pngPages[].path values with OpenClaw message(action=send, media=...).',
+          'If pageCount exceeds three, tell the human the total and that only the first three are included. Main uses its normal assistant response; Management includes the notice in the sessions_send report text.',
+          'Management Session should hand off report text with sessions_send first, then send the selected PNG paths to the Main Session deliveryContext with message(action=send).',
+        ],
+      }),
+      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. Defaults to 2000. 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,
+        });
+        return buildToolResult({ ...report, tool: renderTranscriptTool });
+      },
+    },
   ];
 }
 
@@ -2527,6 +2653,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',
 ]);