@xfxstudio/claworld 0.1.4 → 0.2.0

package/src/openclaw/runtime/product-shell-helper.js

@@ -3,10 +3,6 @@ import { buildRuntimeAuthHeaders } from '../plugin/account-identity.js';
 import { createRuntimeBoundaryError } from '../../lib/runtime-errors.js';
 import {
   buildCandidateDeliverySummary as buildBackendCandidateDeliverySummary,
-  buildResolvedWorldJoinOrchestration as buildBackendResolvedWorldJoinOrchestration,
-  buildWorldJoinOutcomeOrchestration as buildBackendWorldJoinOutcomeOrchestration,
-  buildRequiredFieldExplanation as buildBackendRequiredFieldExplanation,
-  buildWorldProfileCollectionFlow as buildBackendWorldProfileCollectionFlow,
   buildWorldSelectionPrompt as buildBackendWorldSelectionPrompt,
   resolveWorldSelection as resolveBackendWorldSelection,
 } from '../../product-shell/contracts/world-orchestration.js';
@@ -75,13 +71,6 @@ function normalizeProfile(profile = {}) {
   );
 }
 
-function mergeProfileState(profile = {}, profileUpdate = {}) {
-  return {
-    ...normalizeProfile(profile),
-    ...normalizeProfile(profileUpdate),
-  };
-}
-
 function normalizeLookupText(value) {
   return normalizeText(value, '')?.toLowerCase() || '';
 }
@@ -115,12 +104,9 @@ function normalizeWorldSummary(world = {}) {
   return {
     worldId: normalizeText(rawWorldId, 'unknown-world'),
     displayName: normalizeText(summary.displayName || world.displayName, normalizeText(rawWorldId, 'Unknown World')),
-    summary: normalizeText(summary.summary || world.summary, ''),
-    category: normalizeText(summary.category || world.category, 'general'),
+    worldContextText: normalizeText(summary.worldContextText || world.worldContextText, ''),
     hotness: normalizeInteger(summary.hotness || world.hotness || world.activatedMemberCount, 0),
     requiredFieldCount: normalizeInteger(summary.requiredFieldCount || world.requiredFieldCount, 0),
-    matchingMode: normalizeText(summary.matchingMode || world.matchingMode, 'manual_review'),
-    sessionMode: normalizeText(summary.sessionMode || world.sessionMode, 'a2a'),
   };
 }
 
@@ -138,6 +124,22 @@ function normalizeField(field = {}, index = 0, { required = false } = {}) {
   };
 }
 
+function buildParticipantContextField(field = null) {
+  if (field && typeof field === 'object' && !Array.isArray(field)) {
+    return normalizeField(field, 0, { required: true });
+  }
+  return normalizeField({
+    fieldId: 'participantContextText',
+    label: 'Entry Profile',
+    type: 'string',
+    source: 'membership',
+    required: true,
+    description: 'A short text describing who you are in this world and what context you bring into it.',
+    examples: [],
+    constraints: {},
+  }, 0, { required: true });
+}
+
 function normalizeSearchSchema(payload = {}, { worldId = null, fallbackFields = [] } = {}) {
   const rawInputFields = Array.isArray(payload.inputFields) && payload.inputFields.length > 0
     ? payload.inputFields
@@ -181,33 +183,15 @@ function normalizeWorldDetail(payload = {}) {
       source: normalizeText(payload.source, 'product_shell'),
       worldId: normalizedWorldId,
       displayName: normalizeText(payload.displayName, normalizedWorldId),
-      summary: normalizeText(payload.summary, ''),
-      description: normalizeText(payload.description, normalizeText(payload.summary, '')),
-      category: normalizeText(payload.category, 'general'),
+      worldContextText: normalizeText(payload.worldContextText, ''),
+      ownerAgentId: normalizeText(payload.ownerAgentId, null),
+      enabled: typeof payload.enabled === 'boolean' ? payload.enabled : null,
       requiredFieldCount: normalizeInteger(payload.requiredFieldCount, requiredFields.length) || requiredFields.length,
       optionalFieldCount: normalizeInteger(payload.optionalFieldCount, optionalFields.length) || optionalFields.length,
-      matchingMode: normalizeText(payload.matchingMode, 'manual_review'),
-      sessionMode: normalizeText(payload.sessionMode, 'a2a'),
-      interactionRules: normalizeText(payload.interactionRules, null),
-      prohibitedRules: normalizeText(payload.prohibitedRules, null),
-      ratingRules: normalizeText(payload.ratingRules, null),
-      adminAgentIds: normalizeStringList(payload.adminAgentIds),
-      eligibility: normalizeText(payload.eligibility, 'active'),
-      broadcast: normalizeBroadcastConfig(payload.broadcast),
       requiredFields,
       optionalFields,
       hints: normalizeStringList(payload.hints),
       nextAction: normalizeText(payload.nextAction, 'call_join_world'),
-      sessionOverview: payload.sessionOverview && typeof payload.sessionOverview === 'object' ? payload.sessionOverview : {},
-      matchingOverview: payload.matchingOverview && typeof payload.matchingOverview === 'object' ? payload.matchingOverview : {},
-      requiredFieldExplanation:
-        payload.requiredFieldExplanation && typeof payload.requiredFieldExplanation === 'object'
-          ? payload.requiredFieldExplanation
-          : null,
-      runtimeStartupContext:
-        payload.runtimeStartupContext && typeof payload.runtimeStartupContext === 'object'
-          ? payload.runtimeStartupContext
-          : null,
       searchSchema: normalizeSearchSchema(payload.searchSchema || {}, {
         worldId: normalizedWorldId,
         fallbackFields: requiredFields,
@@ -216,63 +200,39 @@ function normalizeWorldDetail(payload = {}) {
   }
 
   const world = payload.world && typeof payload.world === 'object' ? payload.world : {};
-  const agentSummary = payload.agentSummary && typeof payload.agentSummary === 'object' ? payload.agentSummary : {};
+  const management = payload.management && typeof payload.management === 'object' ? payload.management : {};
   const joinSchema = payload.joinSchema && typeof payload.joinSchema === 'object' ? payload.joinSchema : {};
   const fieldGuide = payload.fieldGuide && typeof payload.fieldGuide === 'object' ? payload.fieldGuide : {};
-  const sessionOverview = payload.sessionOverview && typeof payload.sessionOverview === 'object'
-    ? payload.sessionOverview
-    : {};
-  const matchingOverview = payload.matchingOverview && typeof payload.matchingOverview === 'object'
-    ? payload.matchingOverview
-    : {};
   const searchOverview = payload.searchSchema && typeof payload.searchSchema === 'object'
     ? payload.searchSchema
     : {};
+  const participantContextField = buildParticipantContextField(
+    payload.participantContextField
+      || (Array.isArray(fieldGuide.required) ? fieldGuide.required[0] : null)
+      || (Array.isArray(joinSchema.requiredFields) ? joinSchema.requiredFields[0] : null),
+  );
 
-  const requiredInput = Array.isArray(fieldGuide.required) && fieldGuide.required.length > 0
-    ? fieldGuide.required
-    : (Array.isArray(joinSchema.requiredFields) ? joinSchema.requiredFields : []);
-  const optionalInput = Array.isArray(fieldGuide.optional) && fieldGuide.optional.length > 0
-    ? fieldGuide.optional
-    : (Array.isArray(joinSchema.optionalFields) ? joinSchema.optionalFields : []);
-
-  const requiredFields = requiredInput.map((field, index) => normalizeField(field, index, { required: true }));
-  const optionalFields = optionalInput.map((field, index) => normalizeField(field, index, { required: false }));
+  const requiredFields = [participantContextField];
+  const optionalFields = [];
   const worldId = normalizeText(world.worldId || joinSchema.worldId, 'unknown-world');
-  const displayName = normalizeText(agentSummary.displayName || world.displayName, worldId);
+  const displayName = normalizeText(world.displayName, worldId);
 
   return {
     status: 'ready',
     source: 'product_shell',
     worldId,
     displayName,
-    summary: normalizeText(agentSummary.summary || world.summary, ''),
-    description: normalizeText(world.description, normalizeText(agentSummary.summary || world.summary, '')),
-    category: normalizeText(agentSummary.category || world.category, 'general'),
-    requiredFieldCount: normalizeInteger(joinSchema.requiredFieldCount, requiredFields.length) || requiredFields.length,
-    optionalFieldCount: normalizeInteger(joinSchema.optionalFieldCount, optionalFields.length) || optionalFields.length,
-    matchingMode: normalizeText(agentSummary.matchingMode || matchingOverview.mode || world.matching?.mode, 'manual_review'),
-    sessionMode: normalizeText(agentSummary.sessionMode || sessionOverview.mode || world.sessionTemplate?.mode, 'a2a'),
-    interactionRules: normalizeText(world.interactionRules, null),
-    prohibitedRules: normalizeText(world.prohibitedRules, null),
-    ratingRules: normalizeText(world.ratingRules, null),
-    adminAgentIds: normalizeStringList(world.adminAgentIds),
-    eligibility: normalizeText(world.eligibility, 'active'),
-    broadcast: normalizeBroadcastConfig(world.broadcast),
+    worldContextText: normalizeText(world.worldContextText || payload.worldContextText, ''),
+    ownerAgentId: normalizeText(management.ownerAgentId, null),
+    enabled: typeof management.enabled === 'boolean' ? management.enabled : null,
+    statusLabel: normalizeText(management.status, null),
+    requiredFieldCount: 1,
+    optionalFieldCount: 0,
     requiredFields,
     optionalFields,
-    hints: normalizeStringList(joinSchema.hints),
+    participantContextField,
+    hints: [],
     nextAction: normalizeText(joinSchema.nextAction, 'call_join_world'),
-    sessionOverview,
-    matchingOverview,
-    requiredFieldExplanation:
-      payload.requiredFieldExplanation && typeof payload.requiredFieldExplanation === 'object'
-        ? payload.requiredFieldExplanation
-        : null,
-    runtimeStartupContext:
-      payload.runtimeStartupContext && typeof payload.runtimeStartupContext === 'object'
-        ? payload.runtimeStartupContext
-        : null,
     searchSchema: normalizeSearchSchema(searchOverview, {
       worldId,
       fallbackFields: [...requiredFields, ...optionalFields],
@@ -280,59 +240,6 @@ function normalizeWorldDetail(payload = {}) {
   };
 }
 
-function normalizeJoinCheckField(field = {}, index = 0) {
-  return normalizeField(field, index, { required: true });
-}
-
-function normalizeJoinCheckResponse(payload = {}, { worldId = null, profile = {} } = {}) {
-  const missingFields = Array.isArray(payload.missingFields)
-    ? payload.missingFields.map((field, index) => normalizeJoinCheckField(field, index))
-    : [];
-  const guidance = payload.missingFieldGuidance && typeof payload.missingFieldGuidance === 'object'
-    ? payload.missingFieldGuidance
-    : {};
-  const orderedMissingFields = Array.isArray(guidance.orderedMissingFields)
-    ? guidance.orderedMissingFields.map((field, index) => normalizeJoinCheckField(field, index))
-    : missingFields;
-  const fallbackNextMissingField = orderedMissingFields[0] || missingFields[0] || null;
-  const nextMissingField = payload.nextMissingField
-    ? normalizeJoinCheckField(payload.nextMissingField)
-    : (guidance.nextMissingField ? normalizeJoinCheckField(guidance.nextMissingField) : fallbackNextMissingField);
-  const accepted = payload.accepted === true || orderedMissingFields.length === 0;
-
-  return {
-    worldId: normalizeText(payload.worldId, worldId || 'unknown-world'),
-    accepted,
-    status: normalizeText(payload.status, accepted ? 'eligible' : 'needs_profile'),
-    missingFields,
-    nextMissingField,
-    missingFieldGuidance: {
-      mode: normalizeText(guidance.mode, nextMissingField ? 'ordered_required_fields' : 'complete'),
-      orderedMissingFields,
-      orderedMissingFieldIds: normalizeStringList(
-        Array.isArray(guidance.orderedMissingFieldIds)
-          ? guidance.orderedMissingFieldIds
-          : orderedMissingFields.map((field) => field.fieldId),
-      ),
-      nextMissingField,
-      remainingRequiredFieldCount: normalizeInteger(guidance.remainingRequiredFieldCount, orderedMissingFields.length),
-    },
-    normalizedProfile: normalizeProfile(
-      payload.normalizedProfile && typeof payload.normalizedProfile === 'object'
-        ? payload.normalizedProfile
-        : profile,
-    ),
-    nextAction: normalizeText(
-      payload.nextAction,
-      accepted ? 'call_join_world' : 'retry_join_world_after_profile_update',
-    ),
-    profileCollectionFlow:
-      payload.profileCollectionFlow && typeof payload.profileCollectionFlow === 'object'
-        ? payload.profileCollectionFlow
-        : null,
-  };
-}
-
 function normalizeNumber(value, fallback = null) {
   const parsed = Number(value);
   if (!Number.isFinite(parsed)) return fallback;
@@ -422,6 +329,7 @@ function normalizeCandidate(candidate = {}, index = 0) {
     worldId: normalizeText(candidate.worldId, 'unknown-world'),
     targetAgentId: normalizeText(candidate.targetAgentId, null),
     sourceMembershipId: normalizeText(candidate.sourceMembershipId, null),
+    online: candidate.online === true,
     targetAgentId,
     requestChat,
     profileSummary: normalizeCandidateProfileSummary(candidate.profileSummary),
@@ -457,7 +365,7 @@ function normalizeCandidateFeedResponse(payload = {}, { worldId = null, agentId
     candidateDelivery: payload.candidateDelivery && typeof payload.candidateDelivery === 'object'
       ? payload.candidateDelivery
       : null,
-    candidateSource: normalizeText(payload.candidateSource, 'active_memberships'),
+    candidateSource: normalizeText(payload.candidateSource, 'active_memberships_online'),
     candidateModel: payload.candidateModel && typeof payload.candidateModel === 'object' ? payload.candidateModel : {},
     strategy: payload.strategy && typeof payload.strategy === 'object' ? payload.strategy : {},
     limit: normalizeInteger(payload.limit, candidates.length),
@@ -508,50 +416,6 @@ function normalizeWorldJoinResponse(payload = {}, { worldId = null, agentId = nu
   };
 }
 
-function projectMissingRequiredFields(fields = []) {
-  return fields.map((field) => ({
-    fieldId: field.fieldId,
-    label: field.label,
-    description: field.description || null,
-  }));
-}
-
-function buildJoinRequestBody({ agentId = null, profile = {}, profileSnapshot = null } = {}) {
-  const normalizedAgentId = normalizeText(agentId, null);
-  const normalizedProfile = normalizeProfile(profile);
-  const normalizedProfileSnapshot = normalizeProfile(profileSnapshot);
-
-  return {
-    agentId: normalizedAgentId,
-    ...(Object.keys(normalizedProfileSnapshot).length > 0
-      ? { profileSnapshot: normalizedProfileSnapshot }
-      : (Object.keys(normalizedProfile).length > 0 ? { profile: normalizedProfile } : {})),
-  };
-}
-
-function resolveJoinSubmissionProfile({
-  profile = {},
-  profileSnapshot = null,
-  profileUpdate = null,
-  profilePatch = null,
-} = {}) {
-  const normalizedProfile = normalizeProfile(profile);
-  const normalizedProfileSnapshot = normalizeProfile(profileSnapshot);
-  const appliedProfileUpdate = normalizeProfile(profileUpdate || profilePatch || {});
-  const baseProfile = Object.keys(normalizedProfileSnapshot).length > 0
-    ? normalizedProfileSnapshot
-    : normalizedProfile;
-
-  return {
-    baseProfile,
-    appliedProfileUpdate,
-    mergedProfile: mergeProfileState(baseProfile, appliedProfileUpdate),
-    preferProfileSnapshot:
-      Object.keys(normalizedProfileSnapshot).length > 0
-      || Object.keys(appliedProfileUpdate).length > 0,
-  };
-}
-
 function normalizeSearchMatchedField(field = {}, index = 0) {
   return {
     fieldId: normalizeText(field.fieldId, `field_${index + 1}`),
@@ -647,71 +511,6 @@ export function buildCandidateDeliverySummary(candidateFeed = {}, { worldDetail
   return buildBackendCandidateDeliverySummary(candidateFeed, { worldDetail, limit });
 }
 
-function buildFieldLookup(worldDetail = {}) {
-  const detail = normalizeWorldDetail(worldDetail);
-  return new Map(
-    [...detail.requiredFields, ...detail.optionalFields].map((field) => [field.fieldId, field]),
-  );
-}
-
-function selectPromptFields(joinCheck = {}, worldDetail = {}, maxFieldsPerStep = 1) {
-  if (joinCheck.accepted) return [];
-
-  const fieldLookup = buildFieldLookup(worldDetail);
-  const orderedMissingFields = Array.isArray(joinCheck.missingFieldGuidance?.orderedMissingFields)
-    && joinCheck.missingFieldGuidance.orderedMissingFields.length > 0
-    ? joinCheck.missingFieldGuidance.orderedMissingFields
-    : (Array.isArray(joinCheck.missingFields) ? joinCheck.missingFields : []);
-
-  return orderedMissingFields.slice(0, Math.max(1, maxFieldsPerStep)).map((field, index) => {
-    const detailField = fieldLookup.get(field.fieldId) || {};
-    return normalizeField(
-      {
-        ...detailField,
-        ...field,
-        description: normalizeText(field.description, detailField.description || null),
-        examples: Array.isArray(detailField.examples) ? detailField.examples : field.examples,
-        constraints: detailField.constraints || field.constraints,
-      },
-      index,
-      { required: true },
-    );
-  });
-}
-
-function buildProfileFieldPrompt(field = {}, index = 0, total = 1) {
-  const examples = Array.isArray(field.examples) && field.examples.length > 0
-    ? ` Example: ${field.examples.map((example) => quoteExample(example)).join(' or ')}.`
-    : '';
-  const description = sentenceCase(
-    field.description || `Provide ${field.label} so the world can evaluate the profile`,
-    'Provide this field so the world can evaluate the profile.',
-  );
-  const prefix = total > 1 ? `${index + 1}. ` : '';
-
-  return `${prefix}${field.label}. ${description}${examples}`;
-}
-
-function listProvidedRequiredFieldIds(worldDetail = {}, profile = {}, missingFieldIds = []) {
-  const missingSet = new Set(normalizeStringList(missingFieldIds));
-  return normalizeWorldDetail(worldDetail).requiredFields
-    .filter((field) => !missingSet.has(field.fieldId) && !isEmptyProfileValue(profile[field.fieldId]))
-    .map((field) => field.fieldId);
-}
-
-function buildProfileCollectionFollowUp(promptFields = []) {
-  if (promptFields.length === 0) {
-    return 'The current profile is already eligible. Continue with the next world step without restarting profile collection.';
-  }
-
-  const labels = promptFields.map((field) => field.label);
-  if (promptFields.length === 1) {
-    return `After the user answers ${labels[0]}, merge it into the saved profile draft and retry join_world before asking anything else.`;
-  }
-
-  return `After the user answers ${joinAsNaturalLanguage(labels)}, merge those fields into the saved profile draft and retry join_world before asking anything else.`;
-}
-
 function normalizeSelectionInput(selection) {
   if (selection && typeof selection === 'object') {
     const asWorldId = normalizeText(selection.worldId, null);
@@ -983,67 +782,13 @@ export async function fetchWorldDetail({
   return normalizeWorldDetail(detail.body);
 }
 
-export async function fetchWorldJoinCheck({
-  cfg = {},
-  accountId = null,
-  runtimeConfig = null,
-  worldId = null,
-  profile = {},
-  maxFieldsPerStep = null,
-  fetchImpl,
-  logger = console,
-} = {}) {
-  if (typeof fetchImpl !== 'function') {
-    throw new Error('fetch is unavailable for claworld product-shell join-check helper');
-  }
-
-  const resolvedWorldId = normalizeText(worldId, null);
-  if (!resolvedWorldId) {
-    throw new Error('claworld product-shell join-check helper requires worldId');
-  }
-
-  const resolvedRuntimeConfig = runtimeConfig || resolveClaworldRuntimeConfig(cfg, accountId);
-  const baseUrl = normalizeRelayHttpBaseUrl(resolvedRuntimeConfig.serverUrl);
-  const normalizedProfile = normalizeProfile(profile);
-  const joinCheck = await fetchJson(fetchImpl, `${baseUrl}/v1/worlds/${encodeURIComponent(resolvedWorldId)}/join-check`, {
-    method: 'POST',
-    headers: {
-      accept: 'application/json',
-      'content-type': 'application/json',
-      ...(resolvedRuntimeConfig.apiKey ? { 'x-api-key': resolvedRuntimeConfig.apiKey } : {}),
-      ...(resolvedRuntimeConfig.relay?.credentialToken ? { 'x-relay-token': resolvedRuntimeConfig.relay.credentialToken } : {}),
-    },
-    body: JSON.stringify({
-      profile: normalizedProfile,
-      ...(maxFieldsPerStep == null ? {} : { maxFieldsPerStep }),
-    }),
-  });
-
-  if (!joinCheck.ok && joinCheck.status !== 422) {
-    logger.error?.('[claworld:product-shell] world join-check failed', {
-      status: joinCheck.status,
-      worldId: resolvedWorldId,
-      accountId: resolvedRuntimeConfig.accountId || accountId || null,
-      body: joinCheck.body,
-    });
-    throw new Error(`claworld product-shell join-check failed: ${joinCheck.status}`);
-  }
-
-  return normalizeJoinCheckResponse(joinCheck.body, {
-    worldId: resolvedWorldId,
-    profile: normalizedProfile,
-  });
-}
-
 export async function joinWorld({
   cfg = {},
   accountId = null,
   runtimeConfig = null,
   worldId = null,
   agentId = null,
-  profile = {},
-  profileSnapshot = null,
-  maxFieldsPerStep = null,
+  participantContextText = null,
   fetchImpl,
   logger = console,
 } = {}) {
@@ -1063,14 +808,6 @@ export async function joinWorld({
 
   const resolvedRuntimeConfig = runtimeConfig || resolveClaworldRuntimeConfig(cfg, accountId);
   const baseUrl = normalizeRelayHttpBaseUrl(resolvedRuntimeConfig.serverUrl);
-  const requestBody = buildJoinRequestBody({
-    agentId: resolvedAgentId,
-    profile,
-    profileSnapshot,
-  });
-  if (maxFieldsPerStep != null) {
-    requestBody.maxFieldsPerStep = maxFieldsPerStep;
-  }
   const joinResult = await fetchJson(fetchImpl, `${baseUrl}/v1/worlds/${encodeURIComponent(resolvedWorldId)}/join`, {
     method: 'POST',
     headers: {
@@ -1079,7 +816,10 @@ export async function joinWorld({
       ...(resolvedRuntimeConfig.apiKey ? { 'x-api-key': resolvedRuntimeConfig.apiKey } : {}),
       ...(resolvedRuntimeConfig.relay?.credentialToken ? { 'x-relay-token': resolvedRuntimeConfig.relay.credentialToken } : {}),
     },
-    body: JSON.stringify(requestBody),
+    body: JSON.stringify({
+      agentId: resolvedAgentId,
+      participantContextText: normalizeText(participantContextText, null),
+    }),
   });
 
   if (!joinResult.ok) {
@@ -1099,143 +839,6 @@ export async function joinWorld({
   });
 }
 
-export async function submitWorldJoin({
-  cfg = {},
-  accountId = null,
-  runtimeConfig = null,
-  worldId = null,
-  agentId = null,
-  profile = {},
-  profileSnapshot = null,
-  profileUpdate = null,
-  profilePatch = null,
-  worldDetail = null,
-  maxFieldsPerStep = 1,
-  fetchImpl,
-  logger = console,
-} = {}) {
-  if (typeof fetchImpl !== 'function') {
-    throw new Error('fetch is unavailable for claworld product-shell join helper');
-  }
-
-  const resolvedWorldId = normalizeText(worldId, null);
-  if (!resolvedWorldId) {
-    throw new Error('claworld product-shell join helper requires worldId');
-  }
-
-  const resolvedAgentId = normalizeText(agentId, null);
-  if (!resolvedAgentId) {
-    throw new Error('claworld product-shell join helper requires agentId');
-  }
-
-  const resolvedRuntimeConfig = runtimeConfig || resolveClaworldRuntimeConfig(cfg, accountId);
-  const baseUrl = normalizeRelayHttpBaseUrl(resolvedRuntimeConfig.serverUrl);
-  const joinProfile = resolveJoinSubmissionProfile({
-    profile,
-    profileSnapshot,
-    profileUpdate,
-    profilePatch,
-  });
-  const requestBody = buildJoinRequestBody({
-    agentId: resolvedAgentId,
-    profile: joinProfile.mergedProfile,
-    profileSnapshot: joinProfile.preferProfileSnapshot ? joinProfile.mergedProfile : null,
-  });
-  if (maxFieldsPerStep != null) {
-    requestBody.maxFieldsPerStep = maxFieldsPerStep;
-  }
-  const joinResult = await fetchJson(fetchImpl, `${baseUrl}/v1/worlds/${encodeURIComponent(resolvedWorldId)}/join`, {
-    method: 'POST',
-    headers: {
-      accept: 'application/json',
-      'content-type': 'application/json',
-      ...(resolvedRuntimeConfig.apiKey ? { 'x-api-key': resolvedRuntimeConfig.apiKey } : {}),
-      ...(resolvedRuntimeConfig.relay?.credentialToken ? { 'x-relay-token': resolvedRuntimeConfig.relay.credentialToken } : {}),
-    },
-    body: JSON.stringify(requestBody),
-  });
-
-  if (!joinResult.ok && joinResult.status !== 422) {
-    logger.error?.('[claworld:product-shell] world join failed', {
-      status: joinResult.status,
-      worldId: resolvedWorldId,
-      agentId: resolvedAgentId,
-      accountId: resolvedRuntimeConfig.accountId || accountId || null,
-      body: joinResult.body,
-    });
-    throw new Error(`claworld product-shell world join failed: ${joinResult.status}`);
-  }
-
-  if (joinResult.status === 422) {
-    const detail = worldDetail
-      ? normalizeWorldDetail(worldDetail)
-      : await fetchWorldDetail({
-        cfg,
-        accountId,
-        runtimeConfig: resolvedRuntimeConfig,
-        worldId: resolvedWorldId,
-        fetchImpl,
-        logger,
-      });
-    const joinCheck = normalizeJoinCheckResponse(joinResult.body, {
-      worldId: resolvedWorldId,
-      profile: joinProfile.mergedProfile,
-    });
-    const profileCollectionFlow = {
-      ...buildBackendWorldProfileCollectionFlow({
-        worldDetail: detail,
-        joinCheck,
-        profile: joinCheck.normalizedProfile,
-        maxFieldsPerStep,
-      }),
-      worldDetail: detail,
-      joinCheck,
-      profile: joinCheck.normalizedProfile,
-      appliedProfileUpdate: joinProfile.appliedProfileUpdate,
-    };
-
-    return {
-      status: 'needs_profile',
-      worldId: resolvedWorldId,
-      agentId: resolvedAgentId,
-      membershipStatus: normalizeText(joinResult.body?.membershipStatus, 'inactive'),
-      normalizedProfile: profileCollectionFlow.profile,
-      missingFields: projectMissingRequiredFields(joinCheck.missingFields),
-      nextMissingField: joinCheck.nextMissingField
-        ? projectMissingRequiredFields([joinCheck.nextMissingField])[0]
-        : null,
-      nextAction: normalizeText(joinResult.body?.nextAction, 'retry_join_world_after_profile_update'),
-      missingFieldGuidance: joinCheck.missingFieldGuidance,
-      candidateFeed: null,
-      candidateDelivery: null,
-      joinCheck,
-      profileCollectionFlow,
-      profileDraft: profileCollectionFlow.profile,
-      missingRequiredFields: projectMissingRequiredFields(joinCheck.missingFields),
-      orchestration: null,
-    };
-  }
-
-  const normalizedJoinResult = normalizeWorldJoinResponse(joinResult.body, {
-    worldId: resolvedWorldId,
-    agentId: resolvedAgentId,
-  });
-
-  return {
-    status: normalizedJoinResult.status,
-    worldId: normalizedJoinResult.worldId,
-    agentId: normalizedJoinResult.agentId,
-    membershipStatus: normalizedJoinResult.membershipStatus,
-    normalizedProfile: normalizedJoinResult.normalizedProfile,
-    membership: normalizedJoinResult.membership,
-    nextAction: normalizedJoinResult.nextAction,
-    nextStageSummary: normalizedJoinResult.nextStageSummary,
-    candidateFeed: normalizedJoinResult.candidateFeed,
-    candidateDelivery: normalizedJoinResult.candidateDelivery,
-    orchestration: normalizedJoinResult.orchestration || null,
-  };
-}
-
 export async function fetchWorldSearch({
   cfg = {},
   accountId = null,
@@ -1501,89 +1104,6 @@ export async function fetchWorldCandidateFeed({
   });
 }
 
-function buildFieldStepPrompt(field = {}, index = 0, total = 1) {
-  const examples = Array.isArray(field.examples) && field.examples.length > 0
-    ? ` Example: ${field.examples.map((example) => quoteExample(example)).join(' or ')}.`
-    : '';
-  const description = sentenceCase(
-    field.description || `Provide ${field.label} so the world can evaluate the profile`,
-    'Provide this field so the world can evaluate the profile.',
-  );
-
-  return `Step ${index + 1} of ${total}: ${field.label}. ${description}${examples}`;
-}
-
-export function buildRequiredFieldExplanation(worldDetail = {}) {
-  if (worldDetail?.requiredFieldExplanation && typeof worldDetail.requiredFieldExplanation === 'object') {
-    return worldDetail.requiredFieldExplanation;
-  }
-  // Compatibility fallback for older world-detail payloads that do not yet
-  // carry backend-authored required-field explanation.
-  return buildBackendRequiredFieldExplanation(worldDetail);
-}
-
-export async function resolveWorldProfileCollectionFlow({
-  cfg = {},
-  accountId = null,
-  runtimeConfig = null,
-  worldId = null,
-  worldDetail = null,
-  profile = {},
-  profileUpdate = null,
-  profilePatch = null,
-  maxFieldsPerStep = 1,
-  fetchImpl,
-  logger = console,
-} = {}) {
-  const appliedProfileUpdate = normalizeProfile(profileUpdate || profilePatch || {});
-  const mergedProfile = mergeProfileState(profile, appliedProfileUpdate);
-  const detail = worldDetail
-    ? normalizeWorldDetail(worldDetail)
-    : await fetchWorldDetail({
-      cfg,
-      accountId,
-      runtimeConfig,
-      worldId,
-      fetchImpl,
-      logger,
-    });
-  const resolvedWorldId = normalizeText(worldId || detail.worldId, detail.worldId);
-  if (!resolvedWorldId) {
-    throw new Error('claworld product-shell profile collection flow requires worldId');
-  }
-
-  const joinCheck = await fetchWorldJoinCheck({
-    cfg,
-    accountId,
-    runtimeConfig,
-    worldId: resolvedWorldId,
-    profile: mergedProfile,
-    maxFieldsPerStep,
-    fetchImpl,
-    logger,
-  });
-  const backendFlow = joinCheck.profileCollectionFlow && typeof joinCheck.profileCollectionFlow === 'object'
-    ? joinCheck.profileCollectionFlow
-    : buildBackendWorldProfileCollectionFlow({
-      worldDetail: detail,
-      joinCheck,
-      profile: joinCheck.normalizedProfile,
-      maxFieldsPerStep,
-    });
-
-  return {
-    ...backendFlow,
-    appliedProfileUpdate,
-    worldDetail: detail,
-    joinCheck,
-    worldId: resolvedWorldId,
-    displayName: detail.displayName,
-    profile: joinCheck.normalizedProfile,
-    accepted: joinCheck.accepted,
-    status: joinCheck.status,
-  };
-}
-
 export async function resolveWorldSelectionFlow({
   cfg = {},
   accountId = null,
@@ -1591,7 +1111,6 @@ export async function resolveWorldSelectionFlow({
   worldDirectory = null,
   selection = null,
   profile = {},
-  maxFieldsPerStep = 1,
   fetchImpl,
   logger = console,
 } = {}) {
@@ -1641,19 +1160,6 @@ export async function resolveWorldSelectionFlow({
     fetchImpl,
     logger,
   });
-  const requiredFieldExplanation = buildRequiredFieldExplanation(worldDetail);
-  const profileCollectionFlow = await resolveWorldProfileCollectionFlow({
-    cfg,
-    accountId,
-    runtimeConfig,
-    worldId: resolvedSelection.selectedWorld.worldId,
-    worldDetail,
-    profile,
-    maxFieldsPerStep,
-    fetchImpl,
-    logger,
-  });
-
   return {
     status: 'selected',
     source: 'product_shell',
@@ -1661,105 +1167,7 @@ export async function resolveWorldSelectionFlow({
     selection: resolvedSelection.selection,
     selectedWorld: resolvedSelection.selectedWorld,
     worldDetail,
-    requiredFieldExplanation,
-    profileCollectionFlow,
+    participantContextField: worldDetail.participantContextField || null,
     orchestration: resolvedSelection.orchestration || null,
   };
 }
-
-export async function resolveWorldJoinFlow({
-  cfg = {},
-  accountId = null,
-  runtimeConfig = null,
-  worldId = null,
-  worldDetail = null,
-  agentId = null,
-  profile = {},
-  profileSnapshot = null,
-  profileUpdate = null,
-  profilePatch = null,
-  maxFieldsPerStep = 1,
-  limit = null,
-  fetchImpl,
-  logger = console,
-} = {}) {
-  const detail = worldDetail
-    ? normalizeWorldDetail(worldDetail)
-    : await fetchWorldDetail({
-      cfg,
-      accountId,
-      runtimeConfig,
-      worldId,
-      fetchImpl,
-      logger,
-    });
-  const resolvedWorldId = normalizeText(worldId || detail.worldId, detail.worldId);
-  if (!resolvedWorldId) {
-    throw new Error('claworld product-shell join flow requires worldId');
-  }
-
-  const joinResult = await submitWorldJoin({
-    cfg,
-    accountId,
-    runtimeConfig,
-    worldId: resolvedWorldId,
-    agentId,
-    profile,
-    profileSnapshot,
-    profileUpdate,
-    profilePatch,
-    maxFieldsPerStep,
-    fetchImpl,
-    logger,
-  });
-  if (joinResult.status === 'needs_profile') {
-    return joinResult;
-  }
-  const candidateFeed = limit == null && joinResult.candidateFeed
-    ? joinResult.candidateFeed
-    : await fetchWorldCandidateFeed({
-      cfg,
-      accountId,
-      runtimeConfig,
-      worldId: resolvedWorldId,
-      agentId: joinResult.agentId || agentId,
-      limit,
-      fetchImpl,
-      logger,
-    });
-  const candidateDelivery = joinResult.candidateDelivery || buildCandidateDeliverySummary(candidateFeed, {
-    worldDetail: detail,
-    limit,
-  });
-  const joinOrchestration = joinResult.orchestration && typeof joinResult.orchestration === 'object'
-    ? joinResult.orchestration
-    : buildBackendWorldJoinOutcomeOrchestration({
-      worldDetail: detail,
-      joinResult,
-    });
-
-  return {
-    status: candidateDelivery.status,
-    source: 'product_shell',
-    worldId: resolvedWorldId,
-    displayName: detail.displayName,
-    agentId: joinResult.agentId || normalizeText(agentId, null),
-    worldDetail: detail,
-    membershipStatus: joinResult.membershipStatus,
-    normalizedProfile: joinResult.normalizedProfile,
-    membership: joinResult.membership,
-    nextAction: normalizeText(joinResult.nextAction, candidateDelivery.nextAction),
-    nextStageSummary: joinResult.nextStageSummary,
-    joinResult,
-    candidateFeed,
-    candidateDelivery,
-    requestChatAction: candidateDelivery.requestChatAction,
-    orchestration: buildBackendResolvedWorldJoinOrchestration({
-      joinResult: {
-        ...joinResult,
-        orchestration: joinOrchestration,
-      },
-      candidateDelivery,
-    }),
-  };
-}