@xfxstudio/claworld 0.1.4 → 0.2.0

package/src/lib/chat-request.js

@@ -0,0 +1,347 @@
+import { createKickoffBrief } from './relay/kickoff-text.js';
+
+function normalizeText(value, fallback = null) {
+  if (value == null) return fallback;
+  const normalized = String(value).trim();
+  return normalized || fallback;
+}
+
+function cloneJsonObject(value) {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) return null;
+  try {
+    const cloned = JSON.parse(JSON.stringify(value));
+    if (!cloned || typeof cloned !== 'object' || Array.isArray(cloned)) return null;
+    return cloned;
+  } catch {
+    return null;
+  }
+}
+
+export function normalizeChatRequestConversation(input = {}) {
+  if (!input || typeof input !== 'object' || Array.isArray(input)) return {};
+  const conversation = {
+    ...(normalizeText(input.worldId, null) ? { worldId: normalizeText(input.worldId, null) } : {}),
+    ...(normalizeText(input.scope, null)
+      ? { scope: normalizeText(input.scope, null) }
+      : {}),
+    ...(normalizeText(input.conversationId, null) ? { conversationId: normalizeText(input.conversationId, null) } : {}),
+    ...(normalizeText(input.threadId, null) ? { threadId: normalizeText(input.threadId, null) } : {}),
+    ...(normalizeText(input.conversationKey, null) ? { conversationKey: normalizeText(input.conversationKey, null) } : {}),
+    ...(normalizeText(input.sessionKey, null) ? { sessionKey: normalizeText(input.sessionKey, null) } : {}),
+  };
+
+  const episode = cloneJsonObject(input.episode);
+  if (episode) {
+    conversation.episode = episode;
+  }
+  const worldContextText = normalizeText(
+    input.worldContextText,
+    normalizeText(input.worldContext?.worldContextText, normalizeText(input.worldContext?.text, null)),
+  );
+  if (worldContextText) {
+    conversation.worldContextText = worldContextText;
+  }
+
+  return conversation;
+}
+
+export function normalizeChatRequestOrigin(origin = {}, { fallbackType = null } = {}) {
+  if (!origin || typeof origin !== 'object' || Array.isArray(origin)) {
+    const type = normalizeText(fallbackType, null);
+    return type ? { type } : null;
+  }
+
+  const normalized = {
+    ...(normalizeText(origin.type, normalizeText(fallbackType, null))
+      ? { type: normalizeText(origin.type, normalizeText(fallbackType, null)) }
+      : {}),
+    ...(normalizeText(origin.broadcastId, null) ? { broadcastId: normalizeText(origin.broadcastId, null) } : {}),
+  };
+
+  return Object.keys(normalized).length > 0 ? normalized : null;
+}
+
+export function normalizeChatRequestBroadcast(input = {}) {
+  if (!input || typeof input !== 'object' || Array.isArray(input)) return null;
+  const normalized = {
+    ...(normalizeText(input.broadcastId, null) ? { broadcastId: normalizeText(input.broadcastId, null) } : {}),
+    ...(normalizeText(input.worldId, null) ? { worldId: normalizeText(input.worldId, null) } : {}),
+    ...(normalizeText(input.audience, null) ? { audience: normalizeText(input.audience, null) } : {}),
+    ...(normalizeText(input.senderRole, null) ? { senderRole: normalizeText(input.senderRole, null) } : {}),
+    ...(normalizeText(input.eligibility, null) ? { eligibility: normalizeText(input.eligibility, null) } : {}),
+    ...(typeof input.excludeSelf === 'boolean' ? { excludeSelf: input.excludeSelf } : {}),
+  };
+  return Object.keys(normalized).length > 0 ? normalized : null;
+}
+
+export function normalizeChatRequestOpeningPayload(input = null) {
+  if (!input || typeof input !== 'object' || Array.isArray(input)) return null;
+  const payload = cloneJsonObject(input);
+  if (!payload) return null;
+  if (typeof payload.text === 'string') {
+    payload.text = payload.text.trim();
+    if (!payload.text) delete payload.text;
+  }
+  if (typeof payload.source === 'string') {
+    payload.source = payload.source.trim() || undefined;
+  }
+  return Object.keys(payload).length > 0 ? payload : null;
+}
+
+export function resolveChatRequestOpeningMessage({
+  openingMessage = null,
+  openingPayload = null,
+  requestContext = null,
+} = {}) {
+  return normalizeText(
+    openingMessage,
+    normalizeText(openingPayload?.text, normalizeText(requestContext?.message, null)),
+  );
+}
+
+function resolveKickoffBriefSource({
+  kickoffBrief = null,
+  openingPayload = null,
+  requestContext = null,
+  source = null,
+} = {}) {
+  const normalizedContext = requestContext && typeof requestContext === 'object' && !Array.isArray(requestContext)
+    ? requestContext
+    : {};
+  const explicitKickoffBrief = kickoffBrief && typeof kickoffBrief === 'object' && !Array.isArray(kickoffBrief)
+    ? kickoffBrief
+    : null;
+  const contextKickoffBrief = normalizedContext.kickoffBrief && typeof normalizedContext.kickoffBrief === 'object' && !Array.isArray(normalizedContext.kickoffBrief)
+    ? normalizedContext.kickoffBrief
+    : null;
+  const fallbackSource = normalizeText(source, null) === 'world_broadcast'
+    ? 'world_broadcast_brief'
+    : 'chat_request_brief';
+  return normalizeText(
+    explicitKickoffBrief?.source,
+    normalizeText(
+      contextKickoffBrief?.source,
+      normalizeText(
+        openingPayload?.source,
+        normalizeText(normalizedContext.openingPayload?.source, fallbackSource),
+      ),
+    ),
+  );
+}
+
+function resolveChatRequestKickoffBrief({
+  kickoffBrief = null,
+  openingMessage = null,
+  openingPayload = null,
+  requestContext = null,
+  source = null,
+} = {}) {
+  const normalizedContext = requestContext && typeof requestContext === 'object' && !Array.isArray(requestContext)
+    ? requestContext
+    : {};
+  const explicitKickoffBrief = kickoffBrief && typeof kickoffBrief === 'object' && !Array.isArray(kickoffBrief)
+    ? kickoffBrief
+    : null;
+  const contextKickoffBrief = normalizedContext.kickoffBrief && typeof normalizedContext.kickoffBrief === 'object' && !Array.isArray(normalizedContext.kickoffBrief)
+    ? normalizedContext.kickoffBrief
+    : null;
+  const normalizedOpeningPayload = normalizeChatRequestOpeningPayload(
+    explicitKickoffBrief?.payload
+    ?? contextKickoffBrief?.payload
+    ?? openingPayload
+    ?? normalizedContext.openingPayload,
+  );
+  const normalizedOpeningMessage = resolveChatRequestOpeningMessage({
+    openingMessage:
+      explicitKickoffBrief?.text
+      ?? contextKickoffBrief?.text
+      ?? openingMessage,
+    openingPayload: normalizedOpeningPayload,
+    requestContext: normalizedContext,
+  });
+  return createKickoffBrief({
+    text: normalizedOpeningMessage,
+    payload: explicitKickoffBrief?.payload ?? contextKickoffBrief?.payload ?? normalizedOpeningPayload,
+    source: resolveKickoffBriefSource({
+      kickoffBrief: explicitKickoffBrief ?? contextKickoffBrief,
+      openingPayload: normalizedOpeningPayload,
+      requestContext: normalizedContext,
+      source,
+    }),
+  });
+}
+
+export function normalizeChatRequestInput({ requestContext = {}, source = null } = {}) {
+  const normalizedContext = requestContext && typeof requestContext === 'object' && !Array.isArray(requestContext)
+    ? requestContext
+    : {};
+  const conversationSource = normalizedContext.conversation && typeof normalizedContext.conversation === 'object' && !Array.isArray(normalizedContext.conversation)
+    ? normalizedContext.conversation
+    : {};
+  const conversation = normalizeChatRequestConversation({
+    ...conversationSource,
+    conversationKey: normalizedContext.conversationKey ?? conversationSource.conversationKey,
+    sessionKey: normalizedContext.sessionKey ?? conversationSource.sessionKey,
+  });
+  const kickoffBrief = resolveChatRequestKickoffBrief({
+    requestContext: normalizedContext,
+    source,
+  });
+  const openingPayload = normalizeChatRequestOpeningPayload(kickoffBrief?.payload ?? normalizedContext.openingPayload);
+  const broadcast = normalizeChatRequestBroadcast(normalizedContext.broadcast);
+  let origin = normalizeChatRequestOrigin(normalizedContext.origin, {
+    fallbackType: normalizeText(source, null) === 'world_broadcast' ? 'world_broadcast' : 'chat_request',
+  });
+
+  if (broadcast?.broadcastId && !origin?.broadcastId) {
+    origin = {
+      ...(origin || { type: normalizeText(source, null) === 'world_broadcast' ? 'world_broadcast' : 'chat_request' }),
+      broadcastId: broadcast.broadcastId,
+    };
+  }
+
+  return {
+    kickoffBrief,
+    openingMessage: resolveChatRequestOpeningMessage({
+      openingMessage: kickoffBrief?.text ?? null,
+      openingPayload: kickoffBrief?.payload ?? openingPayload,
+      requestContext: normalizedContext,
+    }),
+    openingPayload: kickoffBrief?.payload ?? openingPayload,
+    conversation,
+    origin,
+    broadcast,
+  };
+}
+
+export function buildChatRequestContext({
+  kickoffBrief = null,
+  openingMessage = null,
+  openingPayload = null,
+  conversation = {},
+  origin = null,
+  broadcast = null,
+  source = 'chat_request',
+} = {}) {
+  const normalizedConversation = normalizeChatRequestConversation(conversation);
+  const normalizedKickoffBrief = resolveChatRequestKickoffBrief({
+    kickoffBrief,
+    openingMessage,
+    openingPayload,
+    source,
+  });
+  const normalizedOpeningPayload = normalizeChatRequestOpeningPayload(
+    normalizedKickoffBrief?.payload ?? openingPayload,
+  );
+  const normalizedMessage = resolveChatRequestOpeningMessage({
+    openingMessage: normalizedKickoffBrief?.text ?? openingMessage,
+    openingPayload: normalizedOpeningPayload,
+  });
+  let normalizedOrigin = normalizeChatRequestOrigin(origin, {
+    fallbackType: normalizeText(source, null) === 'world_broadcast' ? 'world_broadcast' : 'chat_request',
+  });
+  let normalizedBroadcast = normalizeChatRequestBroadcast(broadcast);
+
+  if (normalizedOrigin?.broadcastId && !normalizedBroadcast?.broadcastId) {
+    normalizedBroadcast = {
+      ...(normalizedBroadcast || {}),
+      broadcastId: normalizedOrigin.broadcastId,
+    };
+  }
+
+  const requestContext = {
+    type: 'chat_request',
+    ...(normalizedKickoffBrief ? { kickoffBrief: normalizedKickoffBrief } : {}),
+    ...(normalizedMessage ? { message: normalizedMessage } : {}),
+    ...(normalizedOpeningPayload ? { openingPayload: normalizedOpeningPayload } : {}),
+    ...(Object.keys(normalizedConversation).length > 0 ? { conversation: normalizedConversation } : {}),
+    ...(normalizedOrigin ? { origin: normalizedOrigin } : {}),
+    ...(normalizedBroadcast ? { broadcast: normalizedBroadcast } : {}),
+  };
+
+  return requestContext;
+}
+
+export function normalizeStoredChatRequest(input = {}, { defaultSource = 'chat_request' } = {}) {
+  const normalizedSource = normalizeText(input.source, defaultSource);
+  const normalizedRequest = normalizeChatRequestInput({
+    requestContext: input.requestContext,
+    source: normalizedSource,
+  });
+  const kickoffBrief = resolveChatRequestKickoffBrief({
+    kickoffBrief: input.kickoffBrief,
+    openingMessage: input.openingMessage,
+    openingPayload: input.openingPayload ?? normalizedRequest.openingPayload,
+    requestContext: input.requestContext,
+    source: normalizedSource,
+  });
+  const openingPayload = normalizeChatRequestOpeningPayload(
+    input.openingPayload ?? kickoffBrief?.payload ?? normalizedRequest.openingPayload,
+  );
+  const openingMessage = resolveChatRequestOpeningMessage({
+    openingMessage: kickoffBrief?.text ?? input.openingMessage,
+    openingPayload,
+    requestContext: input.requestContext,
+  });
+  const conversation = normalizeChatRequestConversation(
+    input.conversation && typeof input.conversation === 'object' && !Array.isArray(input.conversation)
+      ? input.conversation
+      : normalizedRequest.conversation,
+  );
+  const broadcast = normalizeChatRequestBroadcast(
+    input.broadcast && typeof input.broadcast === 'object' && !Array.isArray(input.broadcast)
+      ? input.broadcast
+      : normalizedRequest.broadcast,
+  );
+  let origin = normalizeChatRequestOrigin(
+    input.origin && typeof input.origin === 'object' && !Array.isArray(input.origin)
+      ? input.origin
+      : normalizedRequest.origin,
+    { fallbackType: normalizedSource === 'world_broadcast' ? 'world_broadcast' : 'chat_request' },
+  );
+
+  if (broadcast?.broadcastId && !origin?.broadcastId) {
+    origin = {
+      ...(origin || { type: normalizedSource === 'world_broadcast' ? 'world_broadcast' : 'chat_request' }),
+      broadcastId: broadcast.broadcastId,
+    };
+  }
+
+  const chatRequestId = normalizeText(input.chatRequestId, normalizeText(input.requestId, null));
+  const normalized = {
+    chatRequestId,
+    requestId: chatRequestId,
+    fromAgentId: normalizeText(input.fromAgentId, null),
+    toAgentId: normalizeText(input.toAgentId, null),
+    toAddress: normalizeText(input.toAddress, null),
+    openingMessage,
+    ...(kickoffBrief ? { kickoffBrief } : {}),
+    ...(openingPayload ? { openingPayload } : {}),
+    conversation,
+    ...(origin ? { origin } : {}),
+    ...(broadcast ? { broadcast } : {}),
+    requestContext: buildChatRequestContext({
+      kickoffBrief,
+      openingMessage,
+      openingPayload,
+      conversation,
+      origin,
+      broadcast,
+      source: normalizedSource,
+    }),
+    status: normalizeText(input.status, 'pending'),
+    createdAt: normalizeText(input.createdAt, null),
+    respondedAt: normalizeText(input.respondedAt, null),
+    expiresAt: normalizeText(input.expiresAt, null),
+    source: normalizedSource,
+  };
+
+  const acceptedByAgentId = normalizeText(input.acceptedByAgentId, null);
+  if (acceptedByAgentId) normalized.acceptedByAgentId = acceptedByAgentId;
+  const approvalGrantId = normalizeText(input.approvalGrantId, null);
+  if (approvalGrantId) normalized.approvalGrantId = approvalGrantId;
+  const kickoff = cloneJsonObject(input.kickoff);
+  if (kickoff) normalized.kickoff = kickoff;
+
+  return normalized;
+}

package/src/lib/{accepted-chat-kickoff.js → relay/kickoff-text.js}

@@ -21,6 +21,43 @@ function normalizeKickoffPayload(input) {
   return cloneJsonObject(input);
 }
 
+function formatScalar(value) {
+  if (value == null) return null;
+  if (typeof value === 'string') return normalizeText(value, null);
+  if (typeof value === 'number' || typeof value === 'boolean') return String(value);
+  return null;
+}
+
+function formatStructuredValue(value, indent = '') {
+  const scalar = formatScalar(value);
+  if (scalar != null) return scalar;
+  if (Array.isArray(value)) {
+    const items = value
+      .map((item) => formatStructuredValue(item, `${indent}  `))
+      .filter(Boolean);
+    if (items.length === 0) return null;
+    return items.map((item) => `${indent}- ${String(item).replace(/\n/g, `\n${indent}  `)}`).join('\n');
+  }
+  if (!value || typeof value !== 'object') return null;
+  const entries = Object.entries(value)
+    .map(([key, entryValue]) => {
+      const formatted = formatStructuredValue(entryValue, `${indent}  `);
+      if (!formatted) return null;
+      if (formatted.includes('\n')) {
+        return `${indent}${key}:\n${formatted}`;
+      }
+      return `${indent}${key}: ${formatted}`;
+    })
+    .filter(Boolean);
+  return entries.length > 0 ? entries.join('\n') : null;
+}
+
+function formatStructuredSection(title, value) {
+  const formatted = formatStructuredValue(value);
+  if (!formatted) return null;
+  return `${title}:\n${formatted}`;
+}
+
 function normalizeKickoffSource(value, fallback = 'chat_request_brief') {
   return normalizeText(value, fallback);
 }
@@ -63,7 +100,7 @@ export function resolveStoredKickoffBrief(requestContext = {}) {
   return createKickoffBrief({
     text: normalizeText(requestContext.openingPayload?.text, normalizeText(requestContext.message, null)),
     payload: requestContext.openingPayload,
-    source: requestContext.openingPayload?.source || 'legacy_chat_request_opening',
+    source: requestContext.openingPayload?.source || 'chat_request_opening',
   });
 }
 
@@ -151,16 +188,28 @@ export function createAcceptedChatKickoffRuntimeContextForAgent(bundle = {}, {
 
 export function formatAcceptedChatKickoffMessage(bundle = {}, { viewer = 'recipient' } = {}) {
   const normalizedViewer = viewer === 'sender' ? 'sender' : 'recipient';
-  const request = bundle.request && typeof bundle.request === 'object' ? bundle.request : {};
-  const conversation = bundle.conversation && typeof bundle.conversation === 'object' ? bundle.conversation : {};
-  const participants = bundle.participants && typeof bundle.participants === 'object' ? bundle.participants : {};
-  const sender = participants.sender && typeof participants.sender === 'object' ? participants.sender : {};
-  const recipient = participants.recipient && typeof participants.recipient === 'object' ? participants.recipient : {};
-  const world = bundle.world && typeof bundle.world === 'object' ? bundle.world : null;
-  const policy = bundle.policy && typeof bundle.policy === 'object' ? bundle.policy : {};
-  const brief = request.brief && typeof request.brief === 'object' ? request.brief : {};
-
-  const worldLabel = normalizeText(world?.displayName, normalizeText(world?.worldId, null));
+  const requestContext = bundle.requestContext && typeof bundle.requestContext === 'object' && !Array.isArray(bundle.requestContext)
+    ? bundle.requestContext
+    : {};
+  const worldInfo = bundle.worldInfo && typeof bundle.worldInfo === 'object' && !Array.isArray(bundle.worldInfo)
+    ? bundle.worldInfo
+    : null;
+  const senderInfo = bundle.senderInfo && typeof bundle.senderInfo === 'object' && !Array.isArray(bundle.senderInfo)
+    ? bundle.senderInfo
+    : (
+      bundle.selfInfo && typeof bundle.selfInfo === 'object' && !Array.isArray(bundle.selfInfo)
+        ? bundle.selfInfo
+        : null
+    );
+  const recipientInfo = bundle.recipientInfo && typeof bundle.recipientInfo === 'object' && !Array.isArray(bundle.recipientInfo)
+    ? bundle.recipientInfo
+    : (
+      bundle.peerInfo && typeof bundle.peerInfo === 'object' && !Array.isArray(bundle.peerInfo)
+        ? bundle.peerInfo
+        : null
+    );
+  const selfInfo = normalizedViewer === 'sender' ? senderInfo : recipientInfo;
+  const peerInfo = normalizedViewer === 'sender' ? recipientInfo : senderInfo;
   const viewerInstruction = normalizedViewer === 'recipient'
     ? 'Use this accepted-chat kickoff context to interpret the sender opener as the first live turn of the accepted chat episode. Decide whether and how to reply. Do not echo the bundle verbatim to the peer.'
     : 'Use this accepted-chat kickoff bundle to craft the first live opener to the recipient. Do not echo the bundle verbatim to the peer.';
@@ -171,21 +220,13 @@ export function formatAcceptedChatKickoffMessage(bundle = {}, { viewer = 'recipi
       : 'Internal Claworld accepted-chat kickoff bundle for the sender runtime.',
     viewerInstruction,
     normalizeText(bundle.requestId, null) ? `Accepted episode: ${bundle.requestId}` : null,
-    normalizeText(conversation.mode, null) ? `Conversation mode: ${conversation.mode}` : null,
-    worldLabel ? `World: ${worldLabel}${world?.worldId ? ` [${world.worldId}]` : ''}` : null,
-    brief.text ? `Sender brief: ${brief.text}` : null,
-    sender.displayName || sender.agentId
-      ? `Sender: ${normalizeText(sender.displayName, sender.agentId)}${sender.agentId ? ` [${sender.agentId}]` : ''}`
-      : null,
-    recipient.displayName || recipient.agentId
-      ? `Recipient: ${normalizeText(recipient.displayName, recipient.agentId)}${recipient.agentId ? ` [${recipient.agentId}]` : ''}`
-      : null,
-    world?.summary ? `World summary: ${world.summary}` : null,
-    world?.sessionContext ? `World session context:\n${JSON.stringify(world.sessionContext, null, 2)}` : null,
-    participants.sender?.worldProfile ? `Sender world profile:\n${JSON.stringify(participants.sender.worldProfile, null, 2)}` : null,
-    participants.recipient?.worldProfile ? `Recipient world profile:\n${JSON.stringify(participants.recipient.worldProfile, null, 2)}` : null,
-    Object.keys(policy).length > 0 ? `Accepted episode policy:\n${JSON.stringify(policy, null, 2)}` : null,
-    brief.payload ? `Structured brief payload:\n${JSON.stringify(brief.payload, null, 2)}` : null,
+    formatStructuredSection('主人想让你做的事情 / 请求上下文', requestContext),
+    formatStructuredSection('世界信息', worldInfo),
+    formatStructuredSection('我方信息', selfInfo),
+    formatStructuredSection('对方信息', peerInfo),
+    normalizedViewer === 'sender'
+      ? '请你现在直接输出一条自然的开场白。不要解释规则，不要复述这些说明。'
+      : '请把对方刚发来的 opener 视为这段对话的第一条 live turn，并决定是否以及如何直接回复。不要解释规则，不要复述这些说明。',
   ].filter(Boolean);
 
   return blocks.join('\n\n');

package/src/openclaw/index.js

@@ -37,17 +37,12 @@ export {
   buildWorldSelectionPrompt,
   resolveWorldSelection,
   fetchWorldDetail,
-  fetchWorldJoinCheck,
   joinWorld,
-  submitWorldJoin,
   fetchWorldSearch,
   submitWorldSearch,
   broadcastWorld,
   fetchWorldCandidateFeed,
   buildCandidateDeliverySummary,
-  buildRequiredFieldExplanation,
-  resolveWorldProfileCollectionFlow,
   resolveWorldSelectionFlow,
-  resolveWorldJoinFlow,
 } from './runtime/product-shell-helper.js';
 export { submitFeedbackReport } from './runtime/feedback-helper.js';

package/src/openclaw/installer/cli.js

@@ -1,9 +1,7 @@
 import os from 'os';
 import path from 'path';
 import {
-  DEFAULT_CLAWORLD_TOOL_PROFILE,
   expandUserPath,
-  normalizeClaworldToolProfile,
 } from '../plugin/managed-config.js';
 import {
   CLAWORLD_DOCTOR_COMMAND,
@@ -37,10 +35,10 @@ Install options:
   --server-url <url>          Override the Claworld backend URL
   --api-key <value>           Override the Claworld backend API key
   --account-id <id>           Managed Claworld account id (default: claworld)
-  --agent-id <id>             Managed local OpenClaw agent id (default: claworld)
-  --workspace <path>          Managed agent workspace path
+  --agent-id <id>             Local OpenClaw agent id to bind claworld onto (default: main)
+  --workspace <path>          Optional dedicated workspace path for claworld-specific bootstrap files
   --display-name <name>       Managed display name override
-  --tool-profile <name>       minimal | default | full (default: ${DEFAULT_CLAWORLD_TOOL_PROFILE})
+  --tool-profile <profile>    minimal | default | full | world
   --repo-root <path>          Local repo root when using --plugin-install-mode link|copy
   --plugin-install-mode <m>   npm | link | copy | skip (default: npm)
   --plugin-source <value>     npm package or local path (default: ${CLAWORLD_INSTALLER_PACKAGE_NAME})
@@ -51,18 +49,18 @@ Update options:
   --server-url <url>          Override the Claworld backend URL
   --api-key <value>           Override the Claworld backend API key
   --account-id <id>           Managed Claworld account id (default: claworld)
-  --agent-id <id>             Managed local OpenClaw agent id (default: claworld)
-  --workspace <path>          Managed agent workspace path
+  --agent-id <id>             Local OpenClaw agent id bound to claworld (default: main)
+  --workspace <path>          Optional dedicated workspace path for claworld-specific bootstrap files
   --display-name <name>       Managed display name override
-  --tool-profile <name>       minimal | default | full (default: ${DEFAULT_CLAWORLD_TOOL_PROFILE})
+  --tool-profile <profile>    minimal | default | full | world
 Doctor options:
   --config <path>             OpenClaw config path (default: ${DEFAULT_OPENCLAW_CONFIG_PATH})
   --state-dir <path>          Optional OPENCLAW_STATE_DIR for OpenClaw commands
   --openclaw-bin <path>       OpenClaw CLI binary (default: ${DEFAULT_OPENCLAW_BIN})
   --server-url <url>          Override the Claworld backend URL
   --account-id <id>           Managed Claworld account id (default: claworld)
-  --agent-id <id>             Managed local OpenClaw agent id (default: claworld)
-  --workspace <path>          Managed workspace path override
+  --agent-id <id>             Local OpenClaw agent id bound to claworld (default: main)
+  --workspace <path>          Optional dedicated workspace path override
   --json                      Print machine-readable result
   --help, -h                  Show this help
 
@@ -92,13 +90,13 @@ export function parseInstallerCliArgs(argv = process.argv.slice(2), env = proces
       serverUrl: null,
       apiKey: null,
       accountId: 'claworld',
-      agentId: 'claworld',
+      agentId: 'main',
       workspace: null,
       displayName: null,
-      toolProfile: DEFAULT_CLAWORLD_TOOL_PROFILE,
       repoRoot: null,
       pluginInstallMode: 'npm',
       pluginInstallSource: CLAWORLD_INSTALLER_PACKAGE_NAME,
+      toolProfile: null,
     },
     update: {
       openclawBin: env.OPENCLAW_BIN || DEFAULT_OPENCLAW_BIN,
@@ -107,10 +105,10 @@ export function parseInstallerCliArgs(argv = process.argv.slice(2), env = proces
       serverUrl: null,
       apiKey: null,
       accountId: 'claworld',
-      agentId: 'claworld',
+      agentId: 'main',
       workspace: null,
       displayName: null,
-      toolProfile: DEFAULT_CLAWORLD_TOOL_PROFILE,
+      toolProfile: null,
     },
     doctor: {
       openclawBin: env.OPENCLAW_BIN || DEFAULT_OPENCLAW_BIN,
@@ -118,7 +116,7 @@ export function parseInstallerCliArgs(argv = process.argv.slice(2), env = proces
       stateDir: env.OPENCLAW_STATE_DIR ? expandUserPath(env.OPENCLAW_STATE_DIR, homeDir) : null,
       serverUrl: null,
       accountId: 'claworld',
-      agentId: 'claworld',
+      agentId: 'main',
       workspace: null,
     },
   };
@@ -187,7 +185,7 @@ export function parseInstallerCliArgs(argv = process.argv.slice(2), env = proces
         index += 1;
         break;
       case '--tool-profile':
-        options.install.toolProfile = normalizeClaworldToolProfile(nextValue(remaining, index));
+        options.install.toolProfile = nextValue(remaining, index);
         options.update.toolProfile = options.install.toolProfile;
         index += 1;
         break;

package/src/openclaw/installer/core.js

@@ -6,13 +6,13 @@ import { spawnSync } from 'child_process';
 import vm from 'vm';
 import {
   DEFAULT_CLAWORLD_ACCOUNT_ID,
+  DEFAULT_CLAWORLD_AGENT_ID,
   DEFAULT_CLAWORLD_SERVER_URL,
   applyClaworldManagedRuntimeConfig,
   ensureObject,
   expandUserPath,
   normalizeText,
   resolveClaworldManagedRuntimeOptions,
-  resolveToolNames,
 } from '../plugin/managed-config.js';
 import {
   defaultClaworldAccountId,
@@ -58,13 +58,7 @@ export function hasManagedBinding(config = {}, { agentId, accountId } = {}) {
 }
 
 export function isManagedToolAllowlistReady(config = {}, options = {}) {
-  const allow = new Set(
-    (Array.isArray(config?.tools?.allow) ? config.tools.allow : [])
-      .map((item) => normalizeText(item, null))
-      .filter(Boolean),
-  );
-  if (allow.has('*')) return true;
-  return resolveToolNames(options).every((toolName) => allow.has(toolName));
+  return true;
 }
 
 export function isRelayBootstrapReady(account = {}) {
@@ -474,9 +468,12 @@ function defaultCommandRunner({
     };
   }
 
+  const useShell = process.platform === 'win32' && /\.(cmd|bat)$/i.test(effectiveBin);
   const result = spawnSync(effectiveBin, args, {
     cwd,
     env,
+    shell: useShell,
+    windowsHide: true,
     stdio: capture ? 'pipe' : 'inherit',
     encoding: 'utf8',
   });
@@ -622,9 +619,9 @@ export function inspectManagedClaworldInstall({
   const managedReady = Boolean(
     managedAccountPresent
     && managedRuntimeReady
-    && managedAgentPresent
     && managedBindingPresent
     && toolsReady
+    && (managedOptions.manageAgentEntry !== true || managedAgentPresent)
   );
 
   let statusLabel = 'needs setup';
@@ -1153,7 +1150,7 @@ export async function verifyClaworldInstall({
   configPath = null,
   stateDir = DEFAULT_OPENCLAW_STATE_DIR,
   accountId = DEFAULT_CLAWORLD_ACCOUNT_ID,
-  agentId = DEFAULT_CLAWORLD_ACCOUNT_ID,
+  agentId = DEFAULT_CLAWORLD_AGENT_ID,
   commandRunner = defaultCommandRunner,
   cwd = process.cwd(),
   env = process.env,
@@ -1255,7 +1252,7 @@ async function reconcileManagedClaworldRuntime({
   serverUrl = null,
   apiKey = null,
   accountId = DEFAULT_CLAWORLD_ACCOUNT_ID,
-  agentId = DEFAULT_CLAWORLD_ACCOUNT_ID,
+  agentId = DEFAULT_CLAWORLD_AGENT_ID,
   workspace = null,
   displayName = null,
   toolProfile = null,
@@ -1396,7 +1393,9 @@ async function reconcileManagedClaworldRuntime({
     await writeConfig(configPath, transformed.config, dryRun);
   }
 
-  const workspaceActions = await seedManagedWorkspace(managedOptions, dryRun);
+  const workspaceActions = managedOptions.manageWorkspace
+    ? await seedManagedWorkspace(managedOptions, dryRun)
+    : [];
   await validateOpenclawConfig({
     openclawBin,
     configPath,
@@ -1459,7 +1458,7 @@ export async function runClaworldInstallerInstall({
   serverUrl = null,
   apiKey = null,
   accountId = DEFAULT_CLAWORLD_ACCOUNT_ID,
-  agentId = DEFAULT_CLAWORLD_ACCOUNT_ID,
+  agentId = DEFAULT_CLAWORLD_AGENT_ID,
   workspace = null,
   displayName = null,
   toolProfile = null,
@@ -1559,7 +1558,7 @@ export async function runClaworldInstallerUpdate({
   serverUrl = null,
   apiKey = null,
   accountId = DEFAULT_CLAWORLD_ACCOUNT_ID,
-  agentId = DEFAULT_CLAWORLD_ACCOUNT_ID,
+  agentId = DEFAULT_CLAWORLD_AGENT_ID,
   workspace = null,
   displayName = null,
   toolProfile = null,