@xfxstudio/claworld 2026.6.9-testing.1 → 2026.6.10-testing.1

package/src/openclaw/plugin/managed-config.js

@@ -336,6 +336,25 @@ function inferExistingAgentId(config = {}, accountId = DEFAULT_CLAWORLD_ACCOUNT_
   return DEFAULT_CLAWORLD_AGENT_ID;
 }
 
+const MANAGED_LEGACY_BUNDLED_SKILL_NAMES = Object.freeze([
+  'claworld-main-session',
+  'claworld-manage-worlds',
+  'claworld-help',
+]);
+
+function hasOnlyManagedBundledSkills(value) {
+  if (!Array.isArray(value) || value.length === 0) return false;
+  return value.every((skillName) => MANAGED_LEGACY_BUNDLED_SKILL_NAMES.includes(skillName));
+}
+
+function buildManagedAgentEntry(options = {}) {
+  return {
+    id: options.agentId,
+    workspace: options.workspace,
+    ...(options.agentDirExplicit && options.agentDir ? { agentDir: options.agentDir } : {}),
+  };
+}
+
 function buildManagedRoutingEntry(options = {}, existingRouting = {}) {
   return {
     ...ensureObject(existingRouting),
@@ -488,6 +507,60 @@ export function resolveToolNames({ toolProfile = DEFAULT_CLAWORLD_TOOL_PROFILE }
   return [...baseProfile];
 }
 
+const MANAGED_BUNDLED_SKILL_NAMES = Object.freeze([
+  'claworld-main-session',
+  'claworld-manage-worlds',
+  'claworld-help',
+]);
+
+export function resolveManagedAgentSkills({ toolProfile = DEFAULT_CLAWORLD_TOOL_PROFILE } = {}) {
+  const normalizedProfile = normalizeClaworldToolProfile(toolProfile);
+  return normalizedProfile === 'full' ? undefined : [...MANAGED_BUNDLED_SKILL_NAMES];
+}
+
+function describeToolAllowEntries(toolNames = []) {
+  if (toolNames.length === 1) {
+    return toolNames[0] === '*' ? '1 entry (includes *)' : '1 entry';
+  }
+  return toolNames.includes('*')
+    ? `${toolNames.length} entries (includes *)`
+    : `${toolNames.length} entries`;
+}
+
+export function buildWorkspaceAgentsContent({
+  agentId,
+  accountId,
+  registrationDisplayName,
+  appToken = null,
+  defaultTargetAgentId = null,
+} = {}) {
+  const identityLine = appToken
+    ? '- relay binding is resolved from the configured appToken at runtime'
+    : registrationDisplayName
+      ? '- relay binding is created during runtime bootstrap and persists as backend-issued credentials'
+      : '- activation is pending until the user completes Claworld public identity setup';
+
+  return `# Claworld Channel Agent
+
+This workspace is dedicated to the OpenClaw \`claworld\` channel.
+
+Routing contract:
+
+- local OpenClaw agent id: \`${agentId}\`
+- claworld account id: \`${accountId}\`
+${registrationDisplayName ? `- bootstrap display name: \`${registrationDisplayName}\`` : (appToken ? '- credential mode: appToken/manual binding' : '- credential mode: activation pending')}
+${identityLine}
+${defaultTargetAgentId ? `- default outbound target agentId: \`${defaultTargetAgentId}\`` : '- outbound sends require explicit target agentId inputs'}
+
+Operating rules:
+
+- keep this workspace focused on Claworld relay and world interactions
+- use explicit \`claworld_*\` tools when they are available
+- do not treat this workspace as the user's general-purpose main agent
+- do not treat this as a separately bootstrapped OpenClaw persona
+`;
+}
+
 function buildBoundAgentEntry(existingAgent = {}, agentId) {
   const nextAgent = {
     ...ensureObject(existingAgent),
@@ -497,8 +570,41 @@ function buildBoundAgentEntry(existingAgent = {}, agentId) {
   return nextAgent;
 }
 
+export function buildWorkspaceMemoryContent({
+  agentId,
+  accountId,
+  registrationDisplayName,
+  appToken = null,
+  defaultTargetAgentId = null,
+} = {}) {
+  const identityLine = appToken
+    ? '- relay binding: resolved from appToken at runtime'
+    : registrationDisplayName
+      ? '- relay binding: assigned during runtime bootstrap'
+      : '- relay binding: pending until public identity setup completes';
+
+  return `# Claworld Memory
+
+- workspace owner: \`${agentId}\`
+- claworld account: \`${accountId}\`
+${registrationDisplayName ? `- bootstrap display name: \`${registrationDisplayName}\`` : ''}
+${identityLine}
+${defaultTargetAgentId ? `- default outbound target agentId: \`${defaultTargetAgentId}\`` : ''}
+
+Use this file for durable Claworld-specific notes only.
+
+- keep world rules, pairing context, and recurring counterpart preferences here when they help future Claworld conversations
+- do not duplicate a full standalone OpenClaw bootstrap/persona here
+- prefer channel/world-specific memory over general-purpose assistant memory
+`;
+}
+
+export function resolveDefaultManagedWorkspace(agentId = DEFAULT_CLAWORLD_AGENT_ID) {
+  return `~/.openclaw/workspace-${agentId}`;
+}
+
 export function resolveDefaultManagedDisplayName(accountId = DEFAULT_CLAWORLD_ACCOUNT_ID) {
-  return `${titleCase(accountId)} Channel`;
+  return `${titleCase(accountId)} Channel Agent`;
 }
 
 export function resolveClaworldManagedRuntimeOptions({
@@ -509,6 +615,7 @@ export function resolveClaworldManagedRuntimeOptions({
   installerState = null,
 } = {}) {
   const resolvedAccountId = normalizeText(accountId, DEFAULT_CLAWORLD_ACCOUNT_ID);
+  const attachToExistingAgent = overrides.attachToExistingAgent !== false;
   const existingBackup = findClaworldManagedRuntimeBackup(installerState, resolvedAccountId);
   const inferredAgentId = inferExistingAgentId(cfg, resolvedAccountId)
     || normalizeText(existingBackup.agentId, null);
@@ -516,7 +623,20 @@ export function resolveClaworldManagedRuntimeOptions({
   const existingAgent = findAgentEntry(cfg, agentId);
   const existingAccount = findManagedAccountEntry(cfg, resolvedAccountId);
   const replaceManagedRuntime = overrides.replaceManagedRuntime !== false;
-  const workspace = normalizeText(existingAgent?.workspace, normalizeText(existingBackup.workspace, null));
+  const explicitWorkspace = normalizeText(overrides.workspace, null);
+  const manageAgentEntry = overrides.manageAgentEntry === true
+    || overrides.agentDirExplicit === true
+    || attachToExistingAgent !== true;
+  const manageWorkspace = overrides.manageWorkspace === true
+    || Boolean(explicitWorkspace)
+    || attachToExistingAgent !== true;
+  const defaultWorkspace = manageWorkspace ? resolveDefaultManagedWorkspace(agentId) : null;
+  const workspace = normalizeText(
+    explicitWorkspace,
+    replaceManagedRuntime
+      ? normalizeText(existingAgent?.workspace, normalizeText(existingBackup.workspace, defaultWorkspace))
+      : normalizeText(existingAgent?.workspace, normalizeText(existingBackup.workspace, defaultWorkspace)),
+  );
   const serverUrl = normalizeText(
     overrides.serverUrl,
     normalizeText(input.httpUrl, normalizeText(input.url, normalizeText(existingBackup.serverUrl, DEFAULT_CLAWORLD_SERVER_URL))),
@@ -560,9 +680,14 @@ export function resolveClaworldManagedRuntimeOptions({
 
   return {
     repoRoot: normalizeText(overrides.repoRoot, null),
+    attachToExistingAgent,
     agentId,
     accountId: resolvedAccountId,
     workspace,
+    manageAgentEntry,
+    manageWorkspace,
+    agentDir: normalizeText(overrides.agentDir, null),
+    agentDirExplicit: overrides.agentDirExplicit === true,
     serverUrl,
     apiKey,
     appToken,
@@ -590,6 +715,7 @@ export function applyClaworldManagedRuntimeConfig(inputConfig = {}, options = {}
   const replaceManagedRuntime = options.replaceManagedRuntime !== false;
   const preserveDefaultAccount = options.preserveDefaultAccount === true;
   const sessionDmScope = normalizeText(options.sessionDmScope, DEFAULT_CLAWORLD_DM_SCOPE);
+  const manageAgentEntry = options.manageAgentEntry === true;
 
   const removedManagedToolNames = new Set(CLAWORLD_PUBLIC_TOOL_NAMES);
   if (inputConfig?.tools && typeof inputConfig.tools === 'object') {
@@ -628,18 +754,72 @@ export function applyClaworldManagedRuntimeConfig(inputConfig = {}, options = {}
 
   config.agents = ensureObject(config.agents);
   const existingAgentList = Array.isArray(config.agents.list) ? [...config.agents.list] : [];
-  const agentIndex = findAgentIndex(existingAgentList, options.agentId);
-  if (agentIndex >= 0) {
-    const existingAgent = ensureObject(existingAgentList[agentIndex]);
-    existingAgentList[agentIndex] = buildBoundAgentEntry(existingAgent, options.agentId);
-    config.agents.list = existingAgentList;
-    summary.push(`updated bound agent tool exposure ${options.agentId}`);
+  if (manageAgentEntry) {
+    const managedAgentEntry = buildManagedAgentEntry(options);
+    if (replaceManagedRuntime) {
+      const removedAgentEntries = existingAgentList.filter((item) => ensureObject(item).id === options.agentId).length;
+      config.agents.list = [
+        ...existingAgentList.filter((item) => ensureObject(item).id !== options.agentId),
+        {
+          ...managedAgentEntry,
+          tools: mergeManagedPluginToolExposure(managedAgentEntry.tools),
+        },
+      ];
+      summary.push(
+        removedAgentEntries > 0
+          ? `replaced managed agent entry ${options.agentId}`
+          : `added workspace-scoped agent entry ${options.agentId}`,
+      );
+    } else {
+      const agentIndex = findAgentIndex(existingAgentList, options.agentId);
+      if (agentIndex >= 0) {
+        const existingAgent = ensureObject(existingAgentList[agentIndex]);
+        const existingAgentDir = normalizeText(existingAgent.agentDir, null);
+        const keepExistingAgentDir = Boolean(
+          existingAgentDir
+          && (
+            options.agentDirExplicit
+            || existingAgentDir !== normalizeText(options.agentDir, null)
+          ),
+        );
+        const nextAgentEntry = {
+          ...existingAgent,
+          id: options.agentId,
+          workspace: normalizeText(existingAgent.workspace, options.workspace),
+          ...(keepExistingAgentDir ? { agentDir: existingAgentDir } : {}),
+        };
+        if (!keepExistingAgentDir) {
+          delete nextAgentEntry.agentDir;
+        }
+        if (hasOnlyManagedBundledSkills(existingAgent.skills)) {
+          delete nextAgentEntry.skills;
+        }
+        nextAgentEntry.tools = mergeManagedPluginToolExposure(existingAgent.tools);
+        existingAgentList[agentIndex] = nextAgentEntry;
+        summary.push(`updated existing agent entry ${options.agentId}`);
+      } else {
+        existingAgentList.push({
+          ...managedAgentEntry,
+          tools: mergeManagedPluginToolExposure(managedAgentEntry.tools),
+        });
+        summary.push(`added workspace-scoped agent entry ${options.agentId}`);
+      }
+      config.agents.list = existingAgentList;
+    }
   } else {
-    existingAgentList.push(buildBoundAgentEntry({}, options.agentId));
-    config.agents.list = existingAgentList;
-    summary.push(`added bound agent entry ${options.agentId}`);
+    const agentIndex = findAgentIndex(existingAgentList, options.agentId);
+    if (agentIndex >= 0) {
+      const existingAgent = ensureObject(existingAgentList[agentIndex]);
+      existingAgentList[agentIndex] = buildBoundAgentEntry(existingAgent, options.agentId);
+      config.agents.list = existingAgentList;
+      summary.push(`updated bound agent tool exposure ${options.agentId}`);
+    } else {
+      existingAgentList.push(buildBoundAgentEntry({}, options.agentId));
+      config.agents.list = existingAgentList;
+      summary.push(`added bound agent entry ${options.agentId}`);
+    }
+    summary.push(`attached claworld account ${options.accountId} to existing local agent ${options.agentId}`);
   }
-  summary.push(`attached claworld account ${options.accountId} to local agent ${options.agentId}`);
 
   config.channels = ensureObject(config.channels);
   const existingClaworldRoot = ensureObject(config.channels.claworld);

package/src/openclaw/plugin/onboarding.js

@@ -133,6 +133,7 @@ export function inspectManagedClaworldInstall({
   const setupReady = Boolean(
     managedAccountPresent
     && managedBindingPresent
+    && (managedOptions.manageAgentEntry !== true || managedAgentPresent)
   );
 
   let statusLabel = 'needs setup';
@@ -247,9 +248,7 @@ async function applyManagedOnboardingConfig({
     managedOptions.appToken
       ? 'Activation state: ready via configured appToken'
       : 'Activation state: pending until claworld_manage_account(action=activate_account) runs',
-    'Workspace memory: runtime prompt bootstrap maintains .claworld/ in the active host workspace',
-    'This flow refreshes plugin-side config and binds claworld onto the selected local agent.',
-    'Setup lifecycle: OpenClaw host-native setup.',
+    'This flow refreshes plugin-side config and binds claworld onto the selected local agent. It does not run installer commands or start a backend service.',
   ];
   await prompter.note(
     noteLines.join('\n'),

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

@@ -20,6 +20,7 @@ import {
 } from '../runtime/backend-error-context.js';
 
 export const INTERNAL_REQUESTER_SESSION_KEY_PARAM = '__claworldRequesterSessionKey';
+export const INTERNAL_WORKSPACE_ROOT_PARAM = '__claworldWorkspaceRoot';
 
 export function normalizeText(value, fallback = null) {
   if (value == null) return fallback;
@@ -240,9 +241,10 @@ export async function resolveToolContext(
       runtime: api?.runtime || null,
       accountId,
       runtimeConfig,
-      agentId: normalizeText(params.agentId, runtimeConfig.relay?.agentId || null),
-      requesterSessionKey: normalizeText(params[INTERNAL_REQUESTER_SESSION_KEY_PARAM], null),
-    });
+        agentId: normalizeText(params.agentId, runtimeConfig.relay?.agentId || null),
+        requesterSessionKey: normalizeText(params[INTERNAL_REQUESTER_SESSION_KEY_PARAM], null),
+        workspaceRoot: normalizeText(params[INTERNAL_WORKSPACE_ROOT_PARAM], null),
+      });
     if (
       requiredPublicIdentityCapability
       && (
@@ -282,6 +284,7 @@ export async function resolveToolContext(
     runtimeConfig,
     agentId,
     requesterSessionKey: normalizeText(params[INTERNAL_REQUESTER_SESSION_KEY_PARAM], null),
+    workspaceRoot: normalizeText(params[INTERNAL_WORKSPACE_ROOT_PARAM], null),
   };
 }
 

package/src/openclaw/plugin/register.js

@@ -2,6 +2,10 @@ import {
   createClaworldChannelPlugin,
   recordClaworldRuntimeAssistantOutput,
 } from './claworld-channel-plugin.js';
+import {
+  attachConversationViewerToPayload,
+  buildConversationViewerRoute,
+} from './conversation-viewer.js';
 import {
   projectToolChatRequestMutationResponse,
   projectToolCreateWorldResponse,
@@ -41,6 +45,7 @@ import {
   inferChatInboxAction,
   inferManageWorldAction,
   INTERNAL_REQUESTER_SESSION_KEY_PARAM,
+  INTERNAL_WORKSPACE_ROOT_PARAM,
   integerParam,
   loadCurrentConfig,
   MANAGE_WORLD_ACTIONS,
@@ -267,6 +272,24 @@ function buildTerminalActionResult({ tool, action, payload = {}, status = null }
   });
 }
 
+async function attachLocalConversationViewer(payload, {
+  context = {},
+  params = {},
+  role = null,
+  source = null,
+  logger = console,
+} = {}) {
+  return await attachConversationViewerToPayload(payload, {
+    accountId: context.accountId || null,
+    viewerAgentId: context.agentId || null,
+    role,
+    source,
+    cfg: context.cfg || {},
+    workspaceRoot: context.workspaceRoot || params[INTERNAL_WORKSPACE_ROOT_PARAM] || null,
+    logger,
+  });
+}
+
 function normalizeChatInboxListFiltersInput(params = {}) {
   const source = normalizeObject(params.filters, {}) || {};
   const normalized = {
@@ -1093,10 +1116,17 @@ function createTerminalToolAdapters(api, plugin, internalTools) {
             conversationKey,
             localSessionKey,
           });
+          const payloadWithViewer = await attachLocalConversationViewer(payload, {
+            context,
+            params,
+            role: 'participant',
+            source: 'close_conversation',
+            logger: getHookLogger(api),
+          });
           return buildTerminalActionResult({
             tool: manageConversationsTool,
             action,
-            payload,
+            payload: payloadWithViewer,
           });
         }
         requireManageWorldField('action', `action must be one of ${TERMINAL_CONVERSATION_ACTIONS.join(', ')}`);
@@ -1691,6 +1721,7 @@ function buildRegisteredTools(api, plugin) {
           'Do not use this tool for replying inside an already-open Claworld chat or for runtime live turns.',
           '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.',
+          'If the result includes conversationViewer.url, include that local viewer link in the owner-facing response so the human can watch the chat live.',
         ],
         examples: [
           {
@@ -1759,7 +1790,14 @@ function buildRegisteredTools(api, plugin) {
           openingMessage: params.openingMessage || null,
           worldId: params.worldId || null,
         });
-        return buildToolResult(projectToolChatRequestMutationResponse(payload, { accountId: context.accountId }));
+        const payloadWithViewer = await attachLocalConversationViewer(payload, {
+          context,
+          params,
+          role: 'requester',
+          source: 'request_chat',
+          logger: getHookLogger(api),
+        });
+        return buildToolResult(projectToolChatRequestMutationResponse(payloadWithViewer, { accountId: context.accountId }));
       },
     },
     {
@@ -1778,6 +1816,7 @@ function buildRegisteredTools(api, plugin) {
           'For user requests to contact, PK, continue, or re-engage a Claworld peer, use claworld_manage_conversations(action=request) with the intended direct or world scope.',
           'Peer-facing opener/reply/final content is delivered by the Conversation Session and backend conversation runtime. Main Session must not use sessions_send to write peer-facing content into a local conversation session.',
           'Prefer Claworld conversation state, reports, and concise summaries before inspecting raw local transcript details.',
+          'If an accept result includes conversationViewer.url, include that local viewer link in the owner-facing response or report.',
           'Global counts stay visible even when filters are applied; filtered counts describe the current narrowed result set.',
           'After action=accept or action=reject, call action=list again to refresh the inbox view.',
         ],
@@ -1868,7 +1907,16 @@ function buildRegisteredTools(api, plugin) {
                 ...context,
                 chatRequestId,
               });
-          return buildToolResult(projectToolChatInboxActionResponse(payload, {
+          const payloadWithViewer = action === 'accept'
+            ? await attachLocalConversationViewer(payload, {
+                context,
+                params,
+                role: 'recipient',
+                source: 'accept_chat_request',
+                logger: getHookLogger(api),
+              })
+            : payload;
+          return buildToolResult(projectToolChatInboxActionResponse(payloadWithViewer, {
             accountId: context.accountId,
             action,
           }));
@@ -2148,7 +2196,7 @@ function buildRegisteredTools(api, plugin) {
   }));
 }
 
-export function registerClaworldPluginFull(api, plugin) {
+export function registerClaworldPluginFull(api, plugin, { fetchImpl = globalThis.fetch } = {}) {
   if (!plugin) {
     throw new Error('registerClaworldPluginFull requires a plugin instance');
   }
@@ -2217,17 +2265,16 @@ export function registerClaworldPluginFull(api, plugin) {
         ? event.params
         : {};
       const requesterSessionKey = normalizeText(ctx?.sessionKey, null);
-      if (
-        toolName !== 'claworld_manage_conversations'
-        || normalizeTerminalConversationAction(params.action, null) !== 'request'
-        || !requesterSessionKey
-      ) {
-        return;
-      }
+      if (toolName !== 'claworld_manage_conversations') return;
       const logger = getHookLogger(api);
+      let workspaceRoot = null;
       try {
-        const workspaceRoot = await resolveHookWorkspaceRoot(api, event, ctx);
-        if (workspaceRoot) {
+        workspaceRoot = await resolveHookWorkspaceRoot(api, event, ctx);
+        if (
+          workspaceRoot
+          && requesterSessionKey
+          && normalizeTerminalConversationAction(params.action, null) === 'request'
+        ) {
           await updateClaworldSessionDirectory(
             workspaceRoot,
             {
@@ -2248,10 +2295,12 @@ export function registerClaworldPluginFull(api, plugin) {
       } catch (error) {
         logger?.warn?.('[claworld:working-memory] unable to update requester session directory', error);
       }
+      if (!requesterSessionKey && !workspaceRoot) return;
       return {
         params: {
           ...params,
-          [INTERNAL_REQUESTER_SESSION_KEY_PARAM]: requesterSessionKey,
+          ...(requesterSessionKey ? { [INTERNAL_REQUESTER_SESSION_KEY_PARAM]: requesterSessionKey } : {}),
+          ...(workspaceRoot ? { [INTERNAL_WORKSPACE_ROOT_PARAM]: workspaceRoot } : {}),
         },
       };
     });
@@ -2280,6 +2329,11 @@ export function registerClaworldPluginFull(api, plugin) {
   }
   if (typeof api.registerHttpRoute === 'function') {
     api.registerHttpRoute(buildClaworldStatusRoute(plugin));
+    api.registerHttpRoute(buildConversationViewerRoute(plugin, {
+      api,
+      fetchImpl,
+      logger: getHookLogger(api),
+    }));
   }
   if (typeof api.registerTool === 'function') {
     const internalTools = new Map(
@@ -2310,7 +2364,7 @@ export function registerClaworldPlugin(api, options = {}) {
   } = options;
   const plugin = existingPlugin || createClaworldChannelPlugin(pluginOptions);
   api.registerChannel({ plugin });
-  registerClaworldPluginFull(api, plugin);
+  registerClaworldPluginFull(api, plugin, pluginOptions);
   return plugin;
 }
 

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

@@ -641,6 +641,35 @@ function projectChatRequestOrigin(origin = {}) {
   };
 }
 
+function projectConversationViewer(viewer = null) {
+  if (!viewer || typeof viewer !== 'object' || Array.isArray(viewer)) return null;
+  const id = normalizeText(viewer.id, normalizeText(viewer.viewerId, null));
+  const url = normalizeText(viewer.url, null);
+  if (!id && !url && normalizeText(viewer.status, null) !== 'unavailable') return null;
+  return {
+    id,
+    status: normalizeText(viewer.status, 'ready'),
+    url,
+    localFile: normalizeText(viewer.localFile, null),
+    fileUrl: normalizeText(viewer.fileUrl, null),
+    chatRequestId: normalizeText(viewer.chatRequestId, null),
+    conversationKey: normalizeText(viewer.conversationKey, null),
+    localSessionKey: normalizeText(viewer.localSessionKey, null),
+    replay: viewer.replay && typeof viewer.replay === 'object' && !Array.isArray(viewer.replay)
+      ? {
+          firstOpenReplaysEndedConversation: typeof viewer.replay.firstOpenReplaysEndedConversation === 'boolean'
+            ? viewer.replay.firstOpenReplaysEndedConversation
+            : null,
+          secondOpenShowsFullTranscript: typeof viewer.replay.secondOpenShowsFullTranscript === 'boolean'
+            ? viewer.replay.secondOpenShowsFullTranscript
+            : null,
+        }
+      : null,
+    note: normalizeText(viewer.note, null),
+    reason: normalizeText(viewer.reason, null),
+  };
+}
+
 function projectChatRequestItem(request = {}) {
   if (!request || typeof request !== 'object') return null;
   const requestContext = request.requestContext && typeof request.requestContext === 'object' && !Array.isArray(request.requestContext)
@@ -656,6 +685,7 @@ function projectChatRequestItem(request = {}) {
       ? request.conversation
       : requestContext.conversation,
   );
+  const conversationViewer = projectConversationViewer(request.conversationViewer);
   return {
     chatRequestId: normalizeText(request.chatRequestId || request.requestId, null),
     status: normalizeText(request.status, 'pending'),
@@ -681,11 +711,13 @@ function projectChatRequestItem(request = {}) {
     toAgent: projectToolAgentSummary(request.toAgent),
     counterparty: projectToolAgentSummary(request.counterparty),
     conversation,
+    ...(conversationViewer ? { conversationViewer } : {}),
   };
 }
 
 function projectChatInboxChatItem(chat = {}) {
   if (!chat || typeof chat !== 'object' || Array.isArray(chat)) return null;
+  const conversationViewer = projectConversationViewer(chat.conversationViewer);
   return {
     chatRequestId: normalizeText(chat.chatRequestId, null),
     status: normalizeText(chat.status, null),
@@ -699,6 +731,7 @@ function projectChatInboxChatItem(chat = {}) {
     counterparty: projectToolAgentSummary(chat.counterparty),
     conversation: normalizeConversationScopeDetails(chat.conversation),
     feedbackSummary: projectConversationFeedbackSummary(chat.feedbackSummary),
+    ...(conversationViewer ? { conversationViewer } : {}),
   };
 }
 
@@ -764,12 +797,19 @@ export function projectToolChatRequestMutationResponse(result = {}, { accountId
   const projectedRequest = projectChatRequestItem(request);
   const kickoff = projectChatRequestKickoff(result.kickoff || result.request?.kickoff);
   const projectedChat = projectChatInboxChatItem(result.chat);
+  const conversationViewer = projectConversationViewer(
+    result.conversationViewer
+    || request?.conversationViewer
+    || result.request?.conversationViewer
+    || result.chat?.conversationViewer,
+  );
   const normalizedStatus = normalizeText(result.status, projectedRequest?.status || 'pending');
   return {
     status: normalizedStatus,
     accountId: normalizeText(accountId, null),
     chatRequest: projectedRequest,
     ...(projectedChat ? { chat: projectedChat } : {}),
+    ...(conversationViewer ? { conversationViewer } : {}),
     kickoff,
     nextAction: normalizeText(
       result.nextAction,