@xfxstudio/claworld 2026.4.16-testing.3 → 2026.4.21-testing.1

package/openclaw.plugin.json

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

package/package.json

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

package/skills/claworld-help/SKILL.md

@@ -297,6 +297,17 @@ openclaw agents bind --agent main --bind claworld:claworld
 - `context.tags`
 - `context.metadata`
 
+这些不是 feedback 入参，不要手填：
+
+- `openclawVersion`
+- `pluginVersion`
+- `modelProvider`
+- `modelId`
+- `osCategory`
+
+这些 diagnostics 由 plugin/runtime 在提交时自动补齐；提交成功后的结果里会回显一份非敏感摘要。
+如果某项当前拿不到，结果里允许是 `null`，但 feedback 仍然应该成功记录。
+
 ## 重要规则
 
 - 多账号环境下始终显式传 `accountId`

package/skills/claworld-join-and-chat/SKILL.md

@@ -411,9 +411,11 @@ world-scoped chat：
 
 - `filters`
 - `counts.global`
+- `counts.global.recentRequestStatusCounts`
 - `counts.global.chatStatusCounts`
 - `counts.filtered`
 - `pendingRequests`
+- `recentRequests`
 - `chats`
 - `chatRequestId`
 - `status`
@@ -426,10 +428,17 @@ world-scoped chat：
 - 不传 `filters` 时，默认同时看 inbound 和 outbound
 - `filters.direction` 用于区分 inbound / outbound
 - `filters.mode` 用于区分 direct / world
-- `filters.status` 用于看 `pending`、`opening`、`ending`、`active`、`silent`、`kickoff_failed`、`ended`
+- `filters.status` 用于看 request 状态 `pending`、`expired`、`rejected`，以及 chat 状态 `opening`、`ending`、`active`、`silent`、`kickoff_failed`、`ended`
 - `filters.worldId`、`filters.chatRequestId`、`filters.conversationKey`、`filters.localSessionKey` 用于精确定位
 - `filters.counterpartyAgentId` 用于按对端缩小范围
 
+list 返回语义：
+
+- `pendingRequests` 只放还可处理的 request
+- `recentRequests` 放已经终态但还没形成 chat 的 request，例如 `expired`、`rejected`
+- `chats` 只放已经建立或 kickoff 中的 chat
+- 如果用户说“昨天还是 pending，今天怎么没了”，先查 `recentRequests`，或直接用 `filters.status=expired|rejected`
+
 ### 处理请求
 
 accept：

package/src/openclaw/host-version.js

@@ -0,0 +1,222 @@
+import { accessSync, constants as FS_CONSTANTS } from 'fs';
+import path from 'path';
+import { spawnSync } from 'child_process';
+
+export const DEFAULT_OPENCLAW_BIN = 'openclaw';
+
+function normalizeText(value, fallback = null) {
+  if (value == null) return fallback;
+  const normalized = String(value).trim();
+  return normalized || fallback;
+}
+
+function createOpenclawVersionError(code, message, context = {}) {
+  const error = new Error(message);
+  error.code = code;
+  error.context = context;
+  return error;
+}
+
+function isExplicitCommandPath(command = '') {
+  const normalized = String(command || '').trim();
+  if (!normalized) return false;
+  return normalized.includes('/') || normalized.includes('\\') || path.isAbsolute(normalized);
+}
+
+function splitPathEnvEntries(pathValue = '') {
+  return String(pathValue || '')
+    .split(path.delimiter)
+    .map((entry) => entry.trim())
+    .filter(Boolean);
+}
+
+function isNodeModulesBinEntry(entry = '') {
+  const normalized = path.resolve(String(entry || ''));
+  return path.basename(normalized) === '.bin'
+    && path.basename(path.dirname(normalized)) === 'node_modules';
+}
+
+function resolveCommandNameCandidates(command = '', env = process.env) {
+  const normalized = String(command || '').trim();
+  if (!normalized) return [];
+  if (process.platform !== 'win32' || path.extname(normalized)) {
+    return [normalized];
+  }
+
+  const pathExt = splitPathEnvEntries(env?.PATHEXT || process.env.PATHEXT || '.COM;.EXE;.BAT;.CMD')
+    .map((ext) => ext.toLowerCase());
+  return [...new Set([normalized, ...pathExt.map((ext) => `${normalized}${ext}`)])];
+}
+
+function hasExecutableAccess(filePath = '') {
+  try {
+    accessSync(filePath, FS_CONSTANTS.X_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function resolveOpenclawCliBinary({
+  openclawBin = DEFAULT_OPENCLAW_BIN,
+  env = process.env,
+} = {}) {
+  const requestedBin = normalizeText(openclawBin, DEFAULT_OPENCLAW_BIN);
+  if (
+    requestedBin !== DEFAULT_OPENCLAW_BIN
+    || isExplicitCommandPath(requestedBin)
+  ) {
+    return {
+      requestedBin,
+      binaryPath: requestedBin,
+      binarySource: isExplicitCommandPath(requestedBin) ? 'explicit_path' : 'explicit_command',
+      skippedLocalBinaryPaths: [],
+    };
+  }
+
+  const candidates = [];
+  for (const entry of splitPathEnvEntries(env?.PATH || process.env.PATH || '')) {
+    for (const name of resolveCommandNameCandidates(requestedBin, env)) {
+      const candidatePath = path.join(entry, name);
+      if (hasExecutableAccess(candidatePath)) {
+        candidates.push(candidatePath);
+      }
+    }
+  }
+
+  const uniqueCandidates = [...new Set(candidates)];
+  const hostCandidates = uniqueCandidates.filter((candidate) => !isNodeModulesBinEntry(path.dirname(candidate)));
+  const localCandidates = uniqueCandidates.filter((candidate) => isNodeModulesBinEntry(path.dirname(candidate)));
+  const binaryPath = hostCandidates[0] || uniqueCandidates[0] || requestedBin;
+
+  return {
+    requestedBin,
+    binaryPath,
+    binarySource: hostCandidates[0]
+      ? 'host_path'
+      : uniqueCandidates[0]
+        ? 'package_local_path'
+        : 'default_command',
+    skippedLocalBinaryPaths: localCandidates.filter((candidate) => candidate !== binaryPath),
+  };
+}
+
+function defaultCommandRunner({
+  bin,
+  args = [],
+  cwd = process.cwd(),
+  env = process.env,
+} = {}) {
+  const result = spawnSync(bin, args, {
+    cwd,
+    env,
+    encoding: 'utf8',
+    stdio: ['ignore', 'pipe', 'pipe'],
+    shell: false,
+    windowsHide: true,
+  });
+  if (result.error) throw result.error;
+  return {
+    status: Number.isInteger(result.status) ? result.status : 1,
+    stdout: result.stdout || '',
+    stderr: result.stderr || '',
+  };
+}
+
+function parseCommandVersion(text) {
+  const match = String(text || '').match(/OpenClaw\s+([0-9]+(?:\.[0-9]+)+(?:-[0-9A-Za-z.-]+)?)/i)
+    || String(text || '').match(/([0-9]+(?:\.[0-9]+)+(?:-[0-9A-Za-z.-]+)?)/);
+  return match ? match[1] : null;
+}
+
+async function executeCommand({
+  commandRunner = defaultCommandRunner,
+  bin,
+  args = [],
+  cwd = process.cwd(),
+  env = process.env,
+  dryRun = false,
+  } = {}) {
+  const resolvedBin = resolveOpenclawCliBinary({
+    openclawBin: bin,
+    env,
+  });
+  const effectiveBin = commandRunner === defaultCommandRunner
+    ? resolvedBin.binaryPath
+    : resolvedBin.requestedBin;
+  if (dryRun) {
+    return {
+      status: 0,
+      stdout: '',
+      stderr: '',
+      requestedBin: resolvedBin.requestedBin,
+      resolvedBin: resolvedBin.binaryPath,
+      binSource: resolvedBin.binarySource,
+      skippedBinCandidates: resolvedBin.skippedLocalBinaryPaths,
+    };
+  }
+
+  let result;
+  try {
+    result = await commandRunner({
+      bin: effectiveBin,
+      args,
+      cwd,
+      env,
+    });
+  } catch (error) {
+    throw createOpenclawVersionError(
+      'openclaw_command_failed',
+      error?.message || String(error),
+      {
+        bin: resolvedBin.binaryPath,
+        args,
+      },
+    );
+  }
+
+  return {
+    status: Number.isInteger(result?.status) ? result.status : 1,
+    stdout: result?.stdout || '',
+    stderr: result?.stderr || '',
+    requestedBin: resolvedBin.requestedBin,
+    resolvedBin: resolvedBin.binaryPath,
+    binSource: resolvedBin.binarySource,
+    skippedBinCandidates: resolvedBin.skippedLocalBinaryPaths,
+  };
+}
+
+export async function detectOpenclawHost({
+  openclawBin = DEFAULT_OPENCLAW_BIN,
+  commandRunner = defaultCommandRunner,
+  cwd = process.cwd(),
+  env = process.env,
+  dryRun = false,
+} = {}) {
+  const result = await executeCommand({
+    commandRunner,
+    bin: openclawBin,
+    args: ['--version'],
+    cwd,
+    env,
+    dryRun,
+  });
+  const version = parseCommandVersion(result.stdout || result.stderr);
+  if (!version) {
+    throw createOpenclawVersionError(
+      'openclaw_version_unreadable',
+      'Unable to determine the installed OpenClaw version.',
+      { result },
+    );
+  }
+  return {
+    version,
+    raw: (result.stdout || result.stderr || '').trim(),
+    requestedBin: result.requestedBin || openclawBin,
+    binaryPath: result.resolvedBin || openclawBin,
+    binarySource: result.binSource || 'default_command',
+    skippedLocalBinaryPaths: Array.isArray(result.skippedBinCandidates)
+      ? result.skippedBinCandidates
+      : [],
+  };
+}

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

@@ -2313,6 +2313,8 @@ export function createClaworldChannelPlugin({
         cfg: runtimeContext.cfg || cfg,
         accountId: runtimeConfig.accountId || accountId || null,
         runtimeConfig,
+        runtime: runtimeResolution.runtime,
+        runtimeSource: runtimeResolution.runtimeSource,
         agentId: configuredContext.agentId || runtimeConfig.relay?.agentId || null,
         bindingSource: 'runtime_context',
       };
@@ -2324,6 +2326,8 @@ export function createClaworldChannelPlugin({
       cfg,
       accountId: runtimeConfig.accountId || accountId || null,
       runtimeConfig,
+      runtime: runtimeResolution.runtime,
+      runtimeSource: runtimeResolution.runtimeSource,
       agentId: configuredContext.agentId || runtimeConfig.relay?.agentId || null,
       bindingSource: binding.bindingSource,
     };
@@ -3314,6 +3318,7 @@ async function generateRuntimeProfileCard(context = {}) {
               cfg: resolvedContext.cfg || {},
               accountId: resolvedContext.accountId || null,
               runtimeConfig: resolvedContext.runtimeConfig || null,
+              runtime: resolvedContext.runtime || null,
               agentId: resolvedContext.agentId || null,
               category: context.category || null,
               title: context.title || null,

package/src/openclaw/plugin/register-tooling.js

@@ -161,12 +161,12 @@ export async function loadCurrentConfig(api) {
   if (api?.config && typeof api.config.loadConfig === 'function') {
     return await api.config.loadConfig();
   }
-  if (api?.runtime?.config && typeof api.runtime.config.loadConfig === 'function') {
-    return await api.runtime.config.loadConfig();
-  }
   if (api?.config && typeof api.config === 'object') {
     return api.config;
   }
+  if (api?.runtime?.config && typeof api.runtime.config.loadConfig === 'function') {
+    return await api.runtime.config.loadConfig();
+  }
   return {};
 }
 
@@ -237,6 +237,7 @@ export async function resolveToolContext(
   if (bindRuntime && typeof plugin.helpers?.resolveToolRuntimeContext === 'function') {
     const resolvedContext = await plugin.helpers.resolveToolRuntimeContext({
       cfg,
+      runtime: api?.runtime || null,
       accountId,
       runtimeConfig,
       agentId: normalizeText(params.agentId, runtimeConfig.relay?.agentId || null),

package/src/openclaw/plugin/register.js

@@ -82,6 +82,8 @@ const CHAT_INBOX_FILTER_MODES = Object.freeze([
 ]);
 const CHAT_INBOX_FILTER_STATUSES = Object.freeze([
   'pending',
+  'expired',
+  'rejected',
   'opening',
   'ending',
   'active',
@@ -942,7 +944,7 @@ function buildRegisteredTools(api, plugin) {
           'The backend resolves the target by agentCode.',
           'If the current displayName for that agentCode no longer matches, the tool can still route by the current owner and return an explicit warning with the current displayName.',
           'Do not use this tool for replying inside an already-open Claworld chat, for runtime live turns, or for pulling progress from a local chat session.',
-          'After creation, use claworld_chat_inbox to inspect pending, opening, ending, active, silent, or ended status, or wait for the peer to accept.',
+          'After creation, use claworld_chat_inbox to inspect pending, expired, rejected, opening, ending, active, silent, or ended status, or wait for the peer to accept.',
           'Once accepted, the runtime owns the live conversation loop.',
         ],
         examples: [
@@ -1018,12 +1020,13 @@ function buildRegisteredTools(api, plugin) {
     {
       name: 'claworld_chat_inbox',
       label: 'Claworld Chat Inbox',
-      description: 'Use in the main session to inspect Claworld inbox state or decide one pending chat request. Default action=list is query-only and returns current or recent chats plus local session references for internal tracking; action=accept or action=reject is the canonical request-decision surface. Do not use this tool to send a live message to the peer.',
+      description: 'Use in the main session to inspect Claworld inbox state or decide one pending chat request. Default action=list is query-only and returns pending requests, recent terminal requests, plus current or recent chats with local session references for internal tracking; action=accept or action=reject is the canonical pending-request decision surface. Do not use this tool to send a live message to the peer.',
       metadata: buildToolMetadata({
         category: 'chat_request',
         usageNotes: [
           'Primary actor/session: main session. Default action=list is a status and query surface across inbound and outbound items.',
-          'action=accept and action=reject are request-decision actions for pending requests. They do not send a freeform peer message.',
+          'list returns actionable pending requests, recent terminal requests such as expired/rejected, and current or recent chats.',
+          'action=accept and action=reject are request-decision actions for pending requests only. They do not send a freeform peer message.',
           'Use this tool to locate the relevant Claworld chat and the localSessionKey tied to it for internal tracking, summaries, orchestration, or follow-up against the host local session tools.',
           'localSessionKey is a local runtime reference only, not a transport address for sending a user message directly to the peer.',
           'Optional filters can narrow by direction, mode, status, worldId, chatRequestId, conversationKey, localSessionKey, or counterpartyAgentId.',
@@ -1040,7 +1043,7 @@ function buildRegisteredTools(api, plugin) {
               accountId: 'claworld',
               action: 'list',
             },
-            outcome: 'Returns all pending requests plus related chats for the current account.',
+            outcome: 'Returns pending requests, recent terminal requests, and related chats for the current account.',
           },
           {
             title: 'Filter to active world chats',
@@ -1067,7 +1070,7 @@ function buildRegisteredTools(api, plugin) {
         ],
       }),
       parameters: objectParam({
-        description: 'In the main session, list Claworld inbox state or accept/reject one pending request for the current account. list is query-only; accept/reject are decision-only. Do not use this tool to send a live peer message.',
+        description: 'In the main session, list Claworld inbox state or accept/reject one pending request for the current account. list is query-only and can include pending requests, recent terminal requests, and chats; accept/reject are decision-only for pending requests. Do not use this tool to send a live peer message.',
         required: ['accountId'],
         properties: {
           accountId: accountIdProperty,
@@ -1090,7 +1093,7 @@ function buildRegisteredTools(api, plugin) {
                 examples: ['world'],
               }),
               status: stringParam({
-                description: 'Filter to pending requests or chats by current status.',
+                description: 'Filter to pending or terminal requests, or to chats by current status.',
                 enumValues: CHAT_INBOX_FILTER_STATUSES,
                 examples: ['active'],
               }),

package/src/openclaw/runtime/feedback-diagnostics.js

@@ -0,0 +1,190 @@
+import { detectOpenclawHost } from '../host-version.js';
+import { CLAWORLD_PLUGIN_CURRENT_VERSION } from '../plugin-version.js';
+import { getClaworldRuntime } from '../plugin/runtime.js';
+
+function normalizeText(value, fallback = null) {
+  if (value == null) return fallback;
+  const normalized = String(value).trim();
+  return normalized || fallback;
+}
+
+function normalizeObject(value) {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) return null;
+  return value;
+}
+
+function readPath(source, path) {
+  let current = source;
+  for (const segment of path) {
+    if (!current || typeof current !== 'object' || Array.isArray(current)) {
+      return undefined;
+    }
+    current = current[segment];
+  }
+  return current;
+}
+
+function normalizeModelProvider(value, fallback = null) {
+  if (value == null) return fallback;
+  if (typeof value === 'string') return normalizeText(value, fallback);
+  if (typeof value === 'object' && !Array.isArray(value)) {
+    return normalizeText(value.provider, fallback);
+  }
+  return fallback;
+}
+
+function normalizeModelId(value, fallback = null) {
+  if (value == null) return fallback;
+  if (typeof value === 'string') return normalizeText(value, fallback);
+  if (typeof value === 'object' && !Array.isArray(value)) {
+    return normalizeText(value.id, normalizeText(value.modelId, normalizeText(value.name, fallback)));
+  }
+  return fallback;
+}
+
+function normalizeOsCategory(platform = process.platform) {
+  switch (platform) {
+    case 'darwin':
+      return 'macos';
+    case 'win32':
+      return 'windows';
+    case 'linux':
+      return 'linux';
+    default:
+      return 'other';
+  }
+}
+
+function resolveRuntimeCandidate(contextRuntime = null) {
+  const normalizedContextRuntime = normalizeObject(contextRuntime);
+  if (normalizedContextRuntime) return normalizedContextRuntime;
+  try {
+    return normalizeObject(getClaworldRuntime());
+  } catch {
+    return null;
+  }
+}
+
+async function loadRuntimeConfig(runtime = null) {
+  if (!runtime?.config || typeof runtime.config.loadConfig !== 'function') {
+    return null;
+  }
+  try {
+    return normalizeObject(await runtime.config.loadConfig());
+  } catch {
+    return null;
+  }
+}
+
+const MODEL_PROVIDER_PATHS = [
+  ['agent', 'defaults', 'provider'],
+  ['agent', 'defaults', 'modelProvider'],
+  ['agent', 'defaults', 'model', 'provider'],
+  ['defaults', 'provider'],
+  ['defaults', 'modelProvider'],
+  ['defaults', 'model', 'provider'],
+  ['runtime', 'agent', 'defaults', 'provider'],
+  ['runtime', 'agent', 'defaults', 'modelProvider'],
+  ['runtime', 'agent', 'defaults', 'model', 'provider'],
+  ['runtime', 'defaults', 'provider'],
+  ['runtime', 'defaults', 'modelProvider'],
+  ['runtime', 'defaults', 'model', 'provider'],
+  ['model', 'provider'],
+  ['provider'],
+  ['modelProvider'],
+];
+
+const MODEL_ID_PATHS = [
+  ['agent', 'defaults', 'modelId'],
+  ['agent', 'defaults', 'model', 'id'],
+  ['agent', 'defaults', 'model', 'modelId'],
+  ['agent', 'defaults', 'model', 'name'],
+  ['agent', 'defaults', 'model'],
+  ['defaults', 'modelId'],
+  ['defaults', 'model', 'id'],
+  ['defaults', 'model', 'modelId'],
+  ['defaults', 'model', 'name'],
+  ['defaults', 'model'],
+  ['runtime', 'agent', 'defaults', 'modelId'],
+  ['runtime', 'agent', 'defaults', 'model', 'id'],
+  ['runtime', 'agent', 'defaults', 'model', 'modelId'],
+  ['runtime', 'agent', 'defaults', 'model', 'name'],
+  ['runtime', 'agent', 'defaults', 'model'],
+  ['runtime', 'defaults', 'modelId'],
+  ['runtime', 'defaults', 'model', 'id'],
+  ['runtime', 'defaults', 'model', 'modelId'],
+  ['runtime', 'defaults', 'model', 'name'],
+  ['runtime', 'defaults', 'model'],
+  ['modelId'],
+  ['model', 'id'],
+  ['model', 'modelId'],
+  ['model', 'name'],
+  ['model'],
+];
+
+const OPENCLAW_VERSION_PATHS = [
+  ['host', 'version'],
+  ['openclaw', 'version'],
+  ['meta', 'hostVersion'],
+  ['meta', 'openclawVersion'],
+  ['hostVersion'],
+];
+
+function pickDiagnosticValue(sources, paths, normalizer) {
+  for (const source of sources) {
+    const normalizedSource = normalizeObject(source);
+    if (!normalizedSource) continue;
+    for (const path of paths) {
+      const value = readPath(normalizedSource, path);
+      const normalizedValue = normalizer(value, null);
+      if (normalizedValue) return normalizedValue;
+    }
+  }
+  return null;
+}
+
+function resolveModelDiagnostics(sources = []) {
+  return {
+    modelProvider: pickDiagnosticValue(sources, MODEL_PROVIDER_PATHS, normalizeModelProvider),
+    modelId: pickDiagnosticValue(sources, MODEL_ID_PATHS, normalizeModelId),
+  };
+}
+
+let cachedOpenclawVersionPromise = null;
+
+async function detectOpenclawVersion(runtime = null) {
+  const exposedVersion = pickDiagnosticValue([runtime], OPENCLAW_VERSION_PATHS, normalizeText);
+  if (exposedVersion) return exposedVersion;
+  if (!runtime) return null;
+  if (!cachedOpenclawVersionPromise) {
+    cachedOpenclawVersionPromise = detectOpenclawHost()
+      .then((result) => normalizeText(result?.version, null))
+      .catch(() => null);
+  }
+  return cachedOpenclawVersionPromise;
+}
+
+export async function collectFeedbackDiagnostics({
+  cfg = {},
+  runtime = null,
+  pluginVersion = null,
+} = {}) {
+  const resolvedRuntime = resolveRuntimeCandidate(runtime);
+  const [loadedConfig, openclawVersion] = await Promise.all([
+    loadRuntimeConfig(resolvedRuntime),
+    detectOpenclawVersion(resolvedRuntime),
+  ]);
+  const modelDiagnostics = resolveModelDiagnostics([
+    resolvedRuntime,
+    loadedConfig,
+    cfg,
+  ]);
+
+  return {
+    openclawVersion: normalizeText(openclawVersion, null),
+    pluginVersion: normalizeText(pluginVersion, CLAWORLD_PLUGIN_CURRENT_VERSION),
+    modelProvider: normalizeText(modelDiagnostics.modelProvider, null),
+    modelId: normalizeText(modelDiagnostics.modelId, null),
+    osCategory: normalizeOsCategory(process.platform),
+  };
+}

package/src/openclaw/runtime/feedback-helper.js

@@ -1,6 +1,7 @@
 import { resolveClaworldRuntimeConfig } from '../plugin/config-schema.js';
 import { buildRuntimeAuthHeaders } from '../plugin/account-identity.js';
 import { createRuntimeBoundaryError } from '../../lib/runtime-errors.js';
+import { collectFeedbackDiagnostics } from './feedback-diagnostics.js';
 
 function normalizeText(value, fallback = null) {
   if (value == null) return fallback;
@@ -62,6 +63,7 @@ export async function submitFeedbackReport({
   cfg = {},
   accountId = null,
   runtimeConfig = null,
+  runtime = null,
   agentId = null,
   category = null,
   title = null,
@@ -89,6 +91,11 @@ export async function submitFeedbackReport({
 
   const normalizedContext = normalizeObject(context);
   const resolvedRuntimeConfig = runtimeConfig || resolveClaworldRuntimeConfig(cfg, accountId);
+  const diagnostics = await collectFeedbackDiagnostics({
+    cfg,
+    runtime,
+    pluginVersion,
+  });
   const baseUrl = normalizeRelayHttpBaseUrl(resolvedRuntimeConfig.serverUrl);
   const result = await fetchJson(fetchImpl, `${baseUrl}/v1/feedback`, {
     method: 'POST',
@@ -122,7 +129,7 @@ export async function submitFeedbackReport({
         channelId: 'claworld',
         toolName: 'claworld_submit_feedback',
         toolCallId: normalizeText(toolCallId, null),
-        pluginVersion: normalizeText(pluginVersion, null),
+        ...diagnostics,
         toolContractVersion: normalizeText(toolContractVersion, null),
         accountId: normalizeText(resolvedRuntimeConfig.accountId, normalizeText(accountId, null)),
         serverUrl: baseUrl,

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

@@ -702,7 +702,11 @@ export function projectToolFeedbackSubmissionResponse(result = {}) {
       channelId: normalizeText(runtimeContext.channelId, null),
       toolName: normalizeText(runtimeContext.toolName, null),
       toolCallId: normalizeText(runtimeContext.toolCallId, null),
+      openclawVersion: normalizeText(runtimeContext.openclawVersion, null),
       pluginVersion: normalizeText(runtimeContext.pluginVersion, null),
+      modelProvider: normalizeText(runtimeContext.modelProvider, null),
+      modelId: normalizeText(runtimeContext.modelId, null),
+      osCategory: normalizeText(runtimeContext.osCategory, null),
     },
     nextAction: 'keep_feedback_id_for_follow_up',
   };
@@ -854,6 +858,18 @@ function projectChatInboxFilters(filters = {}) {
 function projectChatInboxCountBlock(counts = {}, fallback = {}) {
   return {
     pendingRequestCount: normalizeInteger(counts.pendingRequestCount, fallback.pendingRequestCount ?? 0),
+    recentRequestCount: normalizeInteger(counts.recentRequestCount, fallback.recentRequestCount ?? 0),
+    recentRequestStatusCounts: counts.recentRequestStatusCounts
+      && typeof counts.recentRequestStatusCounts === 'object'
+      && !Array.isArray(counts.recentRequestStatusCounts)
+      ? {
+          expired: normalizeInteger(counts.recentRequestStatusCounts.expired, 0),
+          rejected: normalizeInteger(counts.recentRequestStatusCounts.rejected, 0),
+        }
+      : {
+          expired: 0,
+          rejected: 0,
+        },
     chatCount: normalizeInteger(counts.chatCount, fallback.chatCount ?? 0),
     chatStatusCounts: counts.chatStatusCounts && typeof counts.chatStatusCounts === 'object' && !Array.isArray(counts.chatStatusCounts)
       ? {
@@ -914,16 +930,21 @@ export function projectToolChatInboxResponse(result = {}, { accountId = null } =
   const pendingRequests = Array.isArray(result.pendingRequests)
     ? result.pendingRequests.map((request) => projectChatRequestItem(request)).filter(Boolean)
     : [];
+  const recentRequests = Array.isArray(result.recentRequests)
+    ? result.recentRequests.map((request) => projectChatRequestItem(request)).filter(Boolean)
+    : [];
   const chats = Array.isArray(result.chats)
     ? result.chats.map((chat) => projectChatInboxChatItem(chat)).filter(Boolean)
     : [];
   const projectedFilters = projectChatInboxFilters(result.filters);
   const globalCounts = projectChatInboxCountBlock(result.counts?.global, {
     pendingRequestCount: pendingRequests.length,
+    recentRequestCount: recentRequests.length,
     chatCount: chats.length,
   });
   const filteredCounts = projectChatInboxCountBlock(result.counts?.filtered, {
     pendingRequestCount: pendingRequests.length,
+    recentRequestCount: recentRequests.length,
     chatCount: chats.length,
   });
   return {
@@ -934,6 +955,7 @@ export function projectToolChatInboxResponse(result = {}, { accountId = null } =
       filtered: filteredCounts,
     },
     pendingRequests,
+    recentRequests,
     chats,
   };
 }