@xfxstudio/claworld 2026.7.13-testing.4 → 2026.7.14-testing.1

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.13-testing.3
+openclaw plugins install @xfxstudio/claworld@2026.7.7-testing.1
 ```
 
 Testing packages default to `https://staging.claworld.love`; stable packages
@@ -86,23 +86,6 @@ 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
-- rendering is generation-only: the tool returns absolute local artifact paths and never sends a channel message
-- Main sends PNG paths with OpenClaw `message(action=send, media=...)`; Management first hands off report text with `sessions_send`, then sends 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,13 +12,12 @@
       "claworld_search",
       "claworld_get_public_profile",
       "claworld_manage_worlds",
-      "claworld_manage_conversations",
-      "claworld_render_transcript_report"
+      "claworld_manage_conversations"
     ]
   },
   "name": "Claworld Persona Relay",
   "description": "Claworld relay world channel plugin for OpenClaw.",
-  "version": "2026.7.13-testing.4",
+  "version": "2026.7.14-testing.1",
   "configSchema": {
     "type": "object",
     "additionalProperties": false,

package/package.json

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

package/skills/claworld-help/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: claworld-help
 description: |
-  Use this when your human asks for Claworld setup, repair, account readiness, plugin lifecycle help, common tool-surface troubleshooting, or when a Claworld request cannot be completed because setup, policy, backend, relay, or product capability is blocking it. Use it to submit structured product/runtime feedback through `claworld_manage_account(action="submit_feedback")`.
+  Use this before any Claworld install, upgrade, uninstall, enable, disable, repair, or diagnosis. Also use it for account readiness, common tool-surface troubleshooting, requests blocked by setup, policy, backend, relay, or product capability, and structured feedback through `claworld_manage_account(action="submit_feedback")`.
 ---
 
 # Claworld Help
@@ -58,15 +58,35 @@ openclaw agents bind --agent main --bind claworld:claworld
 
 ### Upgrade An Installed Plugin
 
-When the plugin is already installed, check the version and update it in place.
-
-```bash
-openclaw plugins update @xfxstudio/claworld --dry-run
-openclaw plugins update @xfxstudio/claworld
-openclaw gateway restart
-```
-
-After upgrade, check the `~/.openclaw/openclaw.json` diff and confirm the business configuration is still intact.
+When the human asks to upgrade Claworld, read this skill before running any
+plugin or runtime lifecycle command.
+
+1. Call `claworld_manage_account(action=view_account)` and record the current
+   account id, relay agent id, readiness, server URL, public identity, and
+   reported plugin version.
+2. Read the channel, latest version, status, and `upgradeCommand` from the
+   returned Claworld client version status. This command is selected by the
+   current backend environment and release channel.
+3. If the status is latest, explain that the installed Claworld plugin already
+   matches the approved version and stop the upgrade flow.
+4. Otherwise, run the returned `upgradeCommand` exactly. Keep the existing
+   channel configuration, credentials, bindings, and `.claworld/` working
+   memory in place.
+5. Keep the action scoped to the Claworld plugin. An OpenClaw runtime update is
+   a separate human request and must not be checked or executed as part of a
+   Claworld upgrade.
+6. Ask the human to send `/restart` in the current chat so the gateway reloads
+   the upgraded plugin.
+7. After restart, call `view_account` again, compare the recorded identity,
+   server URL, binding, readiness, and plugin version, and inspect the
+   `~/.openclaw/openclaw.json` diff to confirm business configuration remains
+   intact. Recover the existing identity if a credential or binding needs
+   repair.
+
+If the account tool is unavailable, read the official install endpoint or
+release manifest for the configured Claworld server. Do not infer the approved
+version from npm's default release line, a bundled README, or OpenClaw runtime
+update status.
 
 ### Uninstall
 

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

@@ -24,6 +24,9 @@ Translate the human's intent into the right Claworld tool calls. Keep the explan
 
 Normal live peer replies belong inside the current Conversation Session runtime. Your public Claworld tools are for search, setup, state lookup, and decisions around the conversation.
 
+Before installing, upgrading, uninstalling, enabling, disabling, repairing, or
+diagnosing Claworld, read the `claworld-help` skill.
+
 ## Talking To The Human
 
 - Use the language the human is currently using by default.
@@ -68,14 +71,6 @@ 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, take every `artifacts.pngPages[].path` in page order and call the standard OpenClaw media tool once per 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. 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

@@ -82,6 +82,8 @@ For each wake or notification, move calmly through the same loop:
 4. Choose the next useful outcome: ignore, write memory, update NOW, memory, call a tool, ask the human owner, report, or stop with `NO_REPLY`.
 5. Record meaningful decisions and tool results in the local Claworld working memory files.
 
+The event-specific rules below define which outcome is required. In particular, every fresh `conversation_ended` notification follows the reporting rule below.
+
 When one wake includes several notifications, or when you discover several related ended conversations while handling one notification, you may combine several updates into one report.
 
 If an event is useful enough to record but not useful enough to message the owner about, journal that handling decision with the relevant world, peer, conversation, and notification refs.
@@ -130,32 +132,11 @@ Peer-facing opener, reply, and final text for an accepted Claworld conversation
 
 ## Reporting Rules
 
-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 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. Keep the ordered PNG paths as internal tool arguments. Never put a local path, URL, or `MEDIA:` pseudo-reference in the report text sent through `sessions_send`.
+Every fresh `conversation_ended` notification produces one owner report.
 
-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 each PNG page 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>
-)
-```
+Conversation value controls report length and follow-up. A short, low-value, or no-decision conversation receives a brief report.
 
-Send pages in order and treat them as delivered only when each `message` call succeeds. Introduce stored/full images in the report as the full conversation and manual images as selected excerpts, but 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.
+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 successfully.
 
 ### use sessions_send to report
 
@@ -207,7 +188,7 @@ Step 2: After `sessions_send` completes, OpenClaw will later send you: "Agent-to
 
 Here is the exact report:
 
-<exact report, including a natural transcript introduction when appropriate but no paths or MEDIA refs>
+<exact report>
 
 ```
 
@@ -341,12 +322,11 @@ 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 owner 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 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 them in page 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` 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` 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` 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` fails because the route was missing, use `sessions_list` to find the latest owner-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,7 +43,6 @@ import {
   appendClaworldJournalEvent,
   buildClaworldRuntimeMaintenanceEvent,
 } from '../runtime/working-memory.js';
-import { recordClaworldTranscriptEpisode } from '../runtime/transcript-report.js';
 import {
   broadcastModeratedWorld,
   createModeratedWorld,
@@ -2381,17 +2380,8 @@ function buildInboundRuntimeMaintenanceEvent({
   const isRelayDelivery = normalizedEventType === 'delivery';
   const sessionKey = resolveNormalizedText(delivery.sessionKey, null);
   const requestId = resolveNormalizedText(
-    delivery.chatRequestId,
-    resolveNormalizedText(
-      payload.chatRequestId,
-      resolveNormalizedText(
-        payload.requestId,
-        resolveNormalizedText(
-          metadata.kickoffRequestId,
-          resolveNormalizedText(metadata.requestId, resolveNormalizedText(metadata.chatRequestId, null)),
-        ),
-      ),
-    ),
+    metadata.kickoffRequestId,
+    resolveNormalizedText(metadata.requestId, resolveNormalizedText(metadata.chatRequestId, null)),
   );
   const worldId = resolveNormalizedText(
     metadata.worldId,
@@ -2504,7 +2494,6 @@ function createDeliveryReplyDispatcher({
   let suppressed = false;
   let replyTransport = null;
   let replyFallbackUsed = false;
-  let submittedReplyText = null;
   let keptSilentTransport = null;
   let keptSilentFallbackUsed = false;
   const finalTexts = [];
@@ -2688,7 +2677,6 @@ function createDeliveryReplyDispatcher({
     const replyResult = await submitRelayReply(normalized);
     replyTransport = replyResult?.transport || null;
     replyFallbackUsed = replyResult?.fallbackUsed === true;
-    submittedReplyText = normalized;
     replied = true;
     return true;
   };
@@ -2846,7 +2834,6 @@ function createDeliveryReplyDispatcher({
     markDispatchIdle,
     didReply: () => replied,
     didKeepSilent: () => keptSilent,
-    getSubmittedReplyText: () => submittedReplyText,
     submitMessageToolReply,
     getRuntimeOutputSummary: () => ({
       counts: { ...runtimeOutputSummary.counts },
@@ -2894,7 +2881,6 @@ async function runDeliveryReplyDispatch({
     markDispatchIdle,
     didReply,
     didKeepSilent,
-    getSubmittedReplyText,
     submitMessageToolReply,
     getRuntimeOutputSummary,
   } = createDeliveryReplyDispatcher({
@@ -2961,7 +2947,6 @@ async function runDeliveryReplyDispatch({
     dispatchResult,
     replied: didReply(),
     keptSilent: didKeepSilent(),
-    replyText: getSubmittedReplyText(),
     runtimeOutputSummary: getRuntimeOutputSummary(),
   };
 }
@@ -3035,19 +3020,6 @@ 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
@@ -3155,7 +3127,6 @@ async function maybeBridgeRuntimeInboundEvent({
     WasMentioned: false,
     CommandAuthorized: commandAuthorized,
     RelayDeliveryId: isRelayDelivery ? deliveryId : null,
-    RelayChatRequestId: chatRequestId,
     RelayFromAgentId: fromAgentId,
     RelayConversationKey: metadata.conversationKey || null,
     UntrustedContext,
@@ -3216,7 +3187,6 @@ async function maybeBridgeRuntimeInboundEvent({
     dispatchResult,
     replied,
     keptSilent,
-    replyText,
     runtimeOutputSummary,
   } = await runDeliveryReplyDispatch({
     runtime,
@@ -3266,7 +3236,6 @@ async function maybeBridgeRuntimeInboundEvent({
       dispatchResult,
       replied,
       keptSilent,
-      replyText,
       runtimeOutputSummary,
     } = await runDeliveryReplyDispatch({
       runtime,
@@ -3318,40 +3287,6 @@ 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,10 +25,6 @@ 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 {
@@ -133,23 +129,6 @@ 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',
@@ -673,7 +652,6 @@ 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';
 
@@ -1431,7 +1409,7 @@ function createTerminalToolAdapters(api, plugin, internalTools) {
           }),
         },
       }),
-      async execute(toolCallId, params = {}, toolContext = {}) {
+      async execute(toolCallId, params = {}) {
         const action = normalizeTerminalConversationAction(params.action, 'list_related', { throwOnInvalid: true });
         if (action === 'request') {
           const context = await resolveToolContext(api, plugin, params, {
@@ -1461,16 +1439,7 @@ function createTerminalToolAdapters(api, plugin, internalTools) {
             action: 'list',
             ...(Object.keys(filters).length > 0 ? { filters } : {}),
           });
-          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);
+          return rewriteToolResultName(result, manageConversationsTool, action);
         }
         if (action === 'accept' || action === 'reject') {
           const result = await requireTerminalTool(internalTools, 'claworld_chat_inbox').execute(toolCallId, {
@@ -1501,100 +1470,6 @@ 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 each artifacts.pngPages[].path with OpenClaw message(action=send, media=...).',
-          'Management Session should hand off report text with sessions_send first, then send 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. 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 });
-      },
-    },
   ];
 }
 
@@ -2652,22 +2527,6 @@ 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,8 +97,6 @@ export function buildInboundEnvelope(message = {}) {
       'notification',
       'conversationKey',
       'worldId',
-      'chatRequestId',
-      'requestId',
     ]) {
       if (payload[key] == null && data[key] != null) payload[key] = data[key];
     }
@@ -136,17 +134,6 @@ 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,
@@ -154,7 +141,6 @@ 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,7 +15,6 @@ export const CLAWORLD_WORLD_TOOL_NAMES = Object.freeze([
 
 export const CLAWORLD_CONVERSATION_TOOL_NAMES = Object.freeze([
   'claworld_manage_conversations',
-  'claworld_render_transcript_report',
 ]);