@xfxstudio/claworld 0.1.4 → 0.2.0

package/src/product-shell/worlds/world-admin-service.js

@@ -1,4 +1,5 @@
 import { WORLD_ACTIONS, WORLD_ROLES } from './world-authorization.js';
+import { buildWorldContextText } from './world-text.js';
 
 function normalizeText(value, fallback = null) {
   if (value == null) return fallback;
@@ -41,6 +42,16 @@ function normalizeBroadcastReplyPolicy(value, fallback = 'zero') {
   return 'zero';
 }
 
+function summarizeWorldContextText(worldContextText, fallback = null) {
+  const normalized = normalizeText(worldContextText, null);
+  if (!normalized) return fallback;
+  const firstLine = normalized
+    .split('\n')
+    .map((line) => line.trim())
+    .find(Boolean);
+  return firstLine || fallback;
+}
+
 function slugify(value, fallback = 'world') {
   const normalized = normalizeText(value, fallback)
     .toLowerCase()
@@ -117,175 +128,49 @@ function normalizeWorldRole(worldRole, fallback = null) {
   return [WORLD_ROLES.OWNER, WORLD_ROLES.ADMIN, WORLD_ROLES.MEMBER].includes(normalized) ? normalized : fallback;
 }
 
-function normalizeFieldType(type) {
-  const normalized = normalizeText(type, 'string');
-  if (['string', 'string[]', 'number', 'boolean'].includes(normalized)) return normalized;
-  throw createInvalidWorldRequestError('entryProfileSchema.fields.type', `unsupported field type: ${normalized}`);
-}
-
-function normalizeEntryProfileField(field = {}, index = 0) {
-  const label = normalizeText(field.label, null);
-  const fieldId = normalizeText(field.fieldId, label ? slugify(label, `field-${index + 1}`) : `field_${index + 1}`);
-  if (!fieldId) {
-    throw createInvalidWorldRequestError('entryProfileSchema.fields.fieldId');
-  }
-
+function buildDefaultEntryProfileField() {
   return {
-    fieldId,
-    label: label || fieldId,
-    type: normalizeFieldType(field.type),
-    required: field.required !== false,
-    searchable: field.searchable === true,
-    description: normalizeText(field.description, null),
-    examples: normalizeStringList(field.examples),
+    fieldId: 'participantContextText',
+    label: 'Entry Profile',
+    type: 'string',
+    required: true,
+    searchable: true,
+    description: 'Free-form participant profile/context text used for world join, search, and candidate review.',
+    examples: [],
   };
 }
 
-function normalizeEntryProfileSchema(input = {}) {
-  const rawFields = Array.isArray(input?.fields) ? input.fields : (Array.isArray(input) ? input : []);
-  if (rawFields.length === 0) {
-    throw createInvalidWorldRequestError('entryProfileSchema.fields', 'at least one profile field is required');
-  }
-
-  const fields = rawFields.map((field, index) => normalizeEntryProfileField(field, index));
-  const fieldIds = new Set();
-  for (const field of fields) {
-    if (fieldIds.has(field.fieldId)) {
-      throw createInvalidWorldRequestError('entryProfileSchema.fields.fieldId', `duplicate fieldId: ${field.fieldId}`);
-    }
-    fieldIds.add(field.fieldId);
-  }
-
-  const requiredFields = fields.filter((field) => field.required);
-  if (requiredFields.length === 0) {
-    throw createInvalidWorldRequestError('entryProfileSchema.fields.required', 'at least one required profile field is required');
-  }
-
-  const searchableFields = fields.filter((field) => field.searchable);
-  if (searchableFields.length === 0) {
-    throw createInvalidWorldRequestError('entryProfileSchema.fields.searchable', 'at least one searchable field is required');
-  }
-
-  return {
-    fields,
-    requiredFields,
-    optionalFields: fields.filter((field) => !field.required),
-    searchableFieldIds: searchableFields.map((field) => field.fieldId),
-  };
-}
-
-function normalizeAdminAgentIds(adminAgentIds, { creatorAgentId = null, store = null } = {}) {
-  if (adminAgentIds == null) return [];
-  if (!Array.isArray(adminAgentIds)) {
-    throw createInvalidWorldRequestError('adminAgentIds', 'adminAgentIds must be an array of agent ids');
-  }
-
-  const normalizedCreatorAgentId = normalizeAgentId(creatorAgentId);
-  const uniqueAgentIds = [];
-  const seen = new Set();
-
-  for (const rawAgentId of adminAgentIds) {
-    const agentId = normalizeAgentId(rawAgentId);
-    if (!agentId || seen.has(agentId) || agentId === normalizedCreatorAgentId) continue;
-    if (store && !store.getAgent(agentId)) {
-      throw createInvalidWorldRequestError('adminAgentIds', `unknown admin agent: ${agentId}`);
-    }
-    seen.add(agentId);
-    uniqueAgentIds.push(agentId);
-  }
-
-  return uniqueAgentIds;
-}
-
-function normalizeBroadcastConfig(broadcast, { existingBroadcast = null } = {}) {
-  if (broadcast !== undefined && (broadcast == null || typeof broadcast !== 'object' || Array.isArray(broadcast))) {
-    throw createInvalidWorldRequestError('broadcast', 'broadcast must be an object');
-  }
-
-  const source = broadcast === undefined ? existingBroadcast : broadcast;
-  const normalized = source && typeof source === 'object' && !Array.isArray(source)
-    ? source
-    : {};
-
-  return {
-    enabled: normalized.enabled === true,
-    audience: normalizeBroadcastAudience(
-      normalized.audience,
-      normalizeBroadcastAudience(existingBroadcast?.audience, 'members'),
-    ),
-    replyPolicy: normalizeBroadcastReplyPolicy(
-      normalized.replyPolicy,
-      normalizeBroadcastReplyPolicy(existingBroadcast?.replyPolicy, 'zero'),
-    ),
-    excludeSelf: normalized.excludeSelf === undefined
-      ? existingBroadcast?.excludeSelf !== false
-      : normalized.excludeSelf !== false,
-  };
-}
-
-function buildSearchSchema(entryProfileSchema) {
+function buildSearchSchema() {
   return {
     mode: 'profile_overlap_search',
-    inputFieldIds: entryProfileSchema.searchableFieldIds,
+    inputFieldIds: ['participantContextText'],
     summary:
-      'Compatibility-only manual search over active online members. Candidate feed review is the canonical path before request_chat.',
+      'Manual world search over active online members using participantContextText. Candidate feed review is the canonical path before request_chat.',
     onlineOnly: true,
     defaultLimit: 10,
   };
 }
 
-function buildMatchingStrategy(entryProfileSchema) {
+function buildMatchingStrategy() {
   return {
     mode: 'profile_overlap',
     cadence: 'on_demand',
     strategySummary:
-      `Rank world members by overlap on ${entryProfileSchema.searchableFieldIds.join(', ')}, deliver candidate summaries first, and let members request_chat after review.`,
-    candidateSources: ['active_memberships'],
+      'Rank active online world members by overlap on participantContextText, deliver candidate summaries first, and let members request_chat after review.',
+    candidateSources: ['active_memberships_online'],
   };
 }
 
-function resolveWorldMaxTurns(sessionTemplate, { existingSessionTemplate = null, required = false } = {}) {
-  const sessionTemplateProvided = sessionTemplate !== undefined;
-  if (sessionTemplateProvided) {
-    if (!sessionTemplate || typeof sessionTemplate !== 'object' || Array.isArray(sessionTemplate)) {
-      throw createInvalidWorldRequestError(
-        'sessionTemplate.maxTurns',
-        'sessionTemplate.maxTurns is required',
-      );
-    }
-
-    const explicitMaxTurns = normalizePositiveInteger(sessionTemplate.maxTurns, null);
-    if (explicitMaxTurns == null) {
-      throw createInvalidWorldRequestError(
-        'sessionTemplate.maxTurns',
-        'sessionTemplate.maxTurns must be a positive integer',
-      );
-    }
-    return explicitMaxTurns;
-  }
-
-  const existingMaxTurns = normalizePositiveInteger(existingSessionTemplate?.maxTurns, null);
-  if (existingMaxTurns != null) return existingMaxTurns;
-  if (required) throw createInvalidWorldRequestError('sessionTemplate.maxTurns');
-  return null;
-}
-
-function buildSessionTemplate(interactionRules, prohibitedRules, { maxTurns, existingSessionTemplate = null } = {}) {
+function buildConversationTemplate(interactionRules, prohibitedRules, { existingConversationTemplate = null } = {}) {
   return {
-    mode: normalizeText(existingSessionTemplate?.mode, 'a2a'),
-    maxTurns,
-    turnTimeoutMs: normalizePositiveInteger(existingSessionTemplate?.turnTimeoutMs, 60_000),
-    raiseHandPolicy: {
-      mode: normalizeText(existingSessionTemplate?.raiseHandPolicy?.mode, 'dual_raise_hand'),
-      summary: prohibitedRules || 'Both agents should stop once neither side has useful new questions.',
-    },
+    mode: normalizeText(existingConversationTemplate?.mode, 'a2a'),
     worldRules: {
       openingText: interactionRules,
-      turnMessageRules: Array.isArray(existingSessionTemplate?.worldRules?.turnMessageRules)
-        ? existingSessionTemplate.worldRules.turnMessageRules
+      turnMessageRules: Array.isArray(existingConversationTemplate?.worldRules?.turnMessageRules)
+        ? existingConversationTemplate.worldRules.turnMessageRules
         : [],
-      convergence: existingSessionTemplate?.worldRules?.convergence || {},
-      stateChangeMessages: existingSessionTemplate?.worldRules?.stateChangeMessages || {},
+      convergence: existingConversationTemplate?.worldRules?.convergence || {},
+      stateChangeMessages: existingConversationTemplate?.worldRules?.stateChangeMessages || {},
     },
   };
 }
@@ -306,31 +191,20 @@ function buildResultContract(worldId, ratingRules) {
 function buildWorldRecord({
   worldId,
   creatorAgentId,
-  adminAgentIds = [],
-  eligibility = 'active',
-  broadcast = undefined,
   displayName,
   summary,
   description,
   interactionRules,
   prohibitedRules,
   ratingRules,
-  entryProfileSchema,
+  worldContextText = null,
   enabled = false,
   status = null,
   schemaVersion = 1,
   existingMetrics = null,
-  sessionTemplate = undefined,
-  existingSessionTemplate = null,
-  existingBroadcast = null,
 } = {}) {
   const resolvedStatus = status || (enabled ? 'enabled' : 'draft');
-  const resolvedMaxTurns = resolveWorldMaxTurns(sessionTemplate, {
-    existingSessionTemplate,
-    required: existingSessionTemplate == null,
-  });
-  const resolvedEligibility = normalizeWorldEligibility(eligibility, 'active');
-  const resolvedBroadcast = normalizeBroadcastConfig(broadcast, { existingBroadcast });
+  const participantContextField = buildDefaultEntryProfileField();
 
   return {
     worldId,
@@ -344,17 +218,25 @@ function buildWorldRecord({
     interactionRules,
     prohibitedRules,
     ratingRules,
+    worldContextText: buildWorldContextText({
+      worldId,
+      displayName,
+      summary,
+      worldContextText,
+      interactionRules,
+      prohibitedRules,
+      ratingRules,
+    }),
     roles: [],
     joinSchema: {
-      requiredFields: entryProfileSchema.requiredFields,
-      optionalFields: entryProfileSchema.optionalFields,
+      requiredFields: [participantContextField],
+      optionalFields: [],
       hints: [],
     },
-    searchSchema: buildSearchSchema(entryProfileSchema),
-    matching: buildMatchingStrategy(entryProfileSchema),
-    sessionTemplate: buildSessionTemplate(interactionRules, prohibitedRules, {
-      maxTurns: resolvedMaxTurns,
-      existingSessionTemplate,
+    searchSchema: buildSearchSchema(),
+    matching: buildMatchingStrategy(),
+    conversationTemplate: buildConversationTemplate(interactionRules, prohibitedRules, {
+      existingConversationTemplate,
     }),
     resultContract: buildResultContract(worldId, ratingRules),
     meta: {
@@ -362,9 +244,14 @@ function buildWorldRecord({
       persistence: 'store',
     },
     creatorAgentId,
-    adminAgentIds,
-    eligibility: resolvedEligibility,
-    broadcast: resolvedBroadcast,
+    adminAgentIds: [],
+    eligibility: 'active',
+    broadcast: {
+      enabled: false,
+      audience: 'members',
+      replyPolicy: 'zero',
+      excludeSelf: true,
+    },
     status: resolvedStatus,
     enabled,
     schemaVersion,
@@ -374,21 +261,13 @@ function buildWorldRecord({
   };
 }
 
-function projectEntryProfileSchema(world = {}) {
+function projectParticipantContextField(world = {}) {
   const requiredFields = Array.isArray(world.joinSchema?.requiredFields) ? world.joinSchema.requiredFields : [];
-  const optionalFields = Array.isArray(world.joinSchema?.optionalFields) ? world.joinSchema.optionalFields : [];
-  const searchableFieldIds = new Set(Array.isArray(world.searchSchema?.inputFieldIds) ? world.searchSchema.inputFieldIds : []);
-
+  const field = requiredFields[0] || buildDefaultEntryProfileField();
   return {
-    fields: [...requiredFields, ...optionalFields].map((field) => ({
-      fieldId: field.fieldId,
-      label: field.label,
-      type: field.type,
-      required: field.required === true,
-      searchable: searchableFieldIds.has(field.fieldId),
-      description: field.description || null,
-      examples: normalizeStringList(field.examples),
-    })),
+    fieldId: field.fieldId,
+    label: field.label,
+    description: field.description || null,
   };
 }
 
@@ -406,7 +285,8 @@ function projectManagedWorldSummary(store, world = {}, { worldRole = null } = {}
   return {
     worldId: world.worldId,
     displayName: world.displayName,
-    summary: world.summary,
+    worldContextText: world.worldContextText || '',
+    ownerAgentId: world.creatorAgentId || null,
     enabled: world.enabled === true,
     status: world.status || 'draft',
     worldRole: normalizeWorldRole(worldRole, null),
@@ -420,24 +300,15 @@ function projectManagedWorld(store, world = {}, { worldRole = null } = {}) {
   return {
     worldId: world.worldId,
     displayName: world.displayName,
-    summary: world.summary,
-    description: world.description,
+    worldContextText: world.worldContextText || '',
+    ownerAgentId: world.creatorAgentId || null,
     enabled: world.enabled === true,
     status: world.status || 'draft',
     worldRole: normalizeWorldRole(worldRole, null),
     schemaVersion: Number(world.schemaVersion || 1),
     createdAt: world.createdAt || null,
     updatedAt: world.updatedAt || null,
-    adminAgentIds: Array.isArray(world.adminAgentIds) ? world.adminAgentIds : [],
-    eligibility: normalizeWorldEligibility(world.eligibility, 'active'),
-    broadcast: normalizeBroadcastConfig(world.broadcast, {
-      existingBroadcast: world.broadcast || null,
-    }),
-    entryProfileSchema: projectEntryProfileSchema(world),
-    interactionRules: world.interactionRules || '',
-    prohibitedRules: world.prohibitedRules || '',
-    ratingRules: world.ratingRules || '',
-    sessionTemplate: world.sessionTemplate || null,
+    participantContextField: projectParticipantContextField(world),
     stats: projectWorldStats(store, world),
   };
 }
@@ -499,60 +370,35 @@ export function createWorldAdminService({ worldService, worldAuthorizationServic
 
   function hasManageWorldChanges(changes = null) {
     if (!changes || typeof changes !== 'object' || Array.isArray(changes)) return false;
-    return Object.keys(changes).some((fieldId) => fieldId !== 'adminAgentIds');
+    return Object.keys(changes).length > 0;
   }
 
   return {
     async createWorld({
       ownerAgentId,
       creatorAgentId,
-      adminAgentIds = [],
-      eligibility = 'active',
-      broadcast = undefined,
       displayName,
-      summary,
-      description,
-      entryProfileSchema,
-      interactionRules,
-      prohibitedRules,
-      ratingRules,
-      sessionTemplate,
+      worldContextText,
       enabled = false,
     } = {}) {
       const storeBacked = assertStore();
       const resolvedOwnerAgentId = assertActorAgent(ownerAgentId || creatorAgentId);
       const resolvedDisplayName = normalizeText(displayName, null);
       if (!resolvedDisplayName) throw createInvalidWorldRequestError('displayName');
-      const resolvedSummary = normalizeText(summary, null);
-      if (!resolvedSummary) throw createInvalidWorldRequestError('summary');
-      const resolvedDescription = normalizeText(description, resolvedSummary);
-      const resolvedInteractionRules = normalizeText(interactionRules, null);
-      if (!resolvedInteractionRules) throw createInvalidWorldRequestError('interactionRules');
-      const resolvedProhibitedRules = normalizeText(prohibitedRules, null);
-      if (!resolvedProhibitedRules) throw createInvalidWorldRequestError('prohibitedRules');
-      const resolvedRatingRules = normalizeText(ratingRules, null);
-      if (!resolvedRatingRules) throw createInvalidWorldRequestError('ratingRules');
-
-      const normalizedEntryProfileSchema = normalizeEntryProfileSchema(entryProfileSchema);
-      const normalizedAdminAgentIds = normalizeAdminAgentIds(adminAgentIds, {
-        creatorAgentId: resolvedOwnerAgentId,
-        store: storeBacked,
-      });
+      const resolvedWorldContextText = normalizeText(worldContextText, null);
+      if (!resolvedWorldContextText) throw createInvalidWorldRequestError('worldContextText');
+
       const worldId = buildWorldId(resolvedDisplayName, worldService.listWorldIds());
       const worldRecord = buildWorldRecord({
         worldId,
         creatorAgentId: resolvedOwnerAgentId,
-        adminAgentIds: normalizedAdminAgentIds,
-        eligibility,
-        broadcast,
         displayName: resolvedDisplayName,
-        summary: resolvedSummary,
-        description: resolvedDescription,
-        interactionRules: resolvedInteractionRules,
-        prohibitedRules: resolvedProhibitedRules,
-        ratingRules: resolvedRatingRules,
-        entryProfileSchema: normalizedEntryProfileSchema,
-        sessionTemplate,
+        summary: summarizeWorldContextText(resolvedWorldContextText, resolvedDisplayName),
+        description: resolvedWorldContextText,
+        interactionRules: null,
+        prohibitedRules: null,
+        ratingRules: null,
+        worldContextText: resolvedWorldContextText,
         enabled: normalizeBoolean(enabled, false),
       });
 
@@ -604,13 +450,6 @@ export function createWorldAdminService({ worldService, worldAuthorizationServic
           action: WORLD_ACTIONS.MANAGE_WORLD,
         });
       }
-      if (hasChanges && Object.prototype.hasOwnProperty.call(changes, 'adminAgentIds')) {
-        authorization = requireWorldAction({
-          worldId,
-          actorAgentId: resolvedActorAgentId,
-          action: WORLD_ACTIONS.MANAGE_WORLD_ROLES,
-        });
-      }
       if (enabled != null) {
         authorization = requireWorldAction({
           worldId,
@@ -631,49 +470,19 @@ export function createWorldAdminService({ worldService, worldAuthorizationServic
 
       if (hasChanges) {
         const nextDisplayName = normalizeText(changes.displayName, existingWorld.displayName);
-        const nextSummary = normalizeText(changes.summary, existingWorld.summary);
-        const nextDescription = normalizeText(changes.description, existingWorld.description);
-        const nextInteractionRules = normalizeText(changes.interactionRules, existingWorld.interactionRules);
-        const nextProhibitedRules = normalizeText(changes.prohibitedRules, existingWorld.prohibitedRules);
-        const nextRatingRules = normalizeText(changes.ratingRules, existingWorld.ratingRules);
-        const nextSessionTemplate = Object.prototype.hasOwnProperty.call(changes, 'sessionTemplate')
-          ? changes.sessionTemplate
-          : undefined;
-        const nextAdminAgentIds = Object.prototype.hasOwnProperty.call(changes, 'adminAgentIds')
-          ? normalizeAdminAgentIds(changes.adminAgentIds, {
-            creatorAgentId: existingWorld.creatorAgentId,
-            store: storeBacked,
-          })
-          : (Array.isArray(existingWorld.adminAgentIds) ? existingWorld.adminAgentIds : []);
-        const nextEligibility = Object.prototype.hasOwnProperty.call(changes, 'eligibility')
-          ? normalizeWorldEligibility(changes.eligibility, existingWorld.eligibility || 'active')
-          : normalizeWorldEligibility(existingWorld.eligibility, 'active');
-        const nextBroadcast = Object.prototype.hasOwnProperty.call(changes, 'broadcast')
-          ? changes.broadcast
-          : undefined;
-        let entryProfileSchema = null;
-
-        if (Object.prototype.hasOwnProperty.call(changes, 'entryProfileSchema')) {
-          entryProfileSchema = normalizeEntryProfileSchema(changes.entryProfileSchema);
-          nextSchemaVersion += 1;
-        }
-
+        const nextWorldContextText = Object.prototype.hasOwnProperty.call(changes, 'worldContextText')
+          ? normalizeText(changes.worldContextText, null)
+          : existingWorld.worldContextText;
         nextRecord = buildWorldRecord({
           worldId: existingWorld.worldId,
           creatorAgentId: existingWorld.creatorAgentId,
-          adminAgentIds: nextAdminAgentIds,
-          eligibility: nextEligibility,
-          broadcast: nextBroadcast,
           displayName: nextDisplayName,
-          summary: nextSummary,
-          description: nextDescription,
-          interactionRules: nextInteractionRules,
-          prohibitedRules: nextProhibitedRules,
-          ratingRules: nextRatingRules,
-          entryProfileSchema: entryProfileSchema || normalizeEntryProfileSchema(projectEntryProfileSchema(existingWorld)),
-          sessionTemplate: nextSessionTemplate,
-          existingSessionTemplate: existingWorld.sessionTemplate || null,
-          existingBroadcast: existingWorld.broadcast || null,
+          summary: summarizeWorldContextText(nextWorldContextText, nextDisplayName),
+          description: nextWorldContextText,
+          interactionRules: null,
+          prohibitedRules: null,
+          ratingRules: null,
+          worldContextText: nextWorldContextText,
           enabled: enabled == null ? existingWorld.enabled === true : normalizeBoolean(enabled, false),
           status: enabled == null
             ? existingWorld.status

package/src/product-shell/worlds/world-authorization.js

@@ -6,7 +6,6 @@ function normalizeText(value, fallback = null) {
 
 export const WORLD_ROLES = Object.freeze({
   OWNER: 'owner',
-  ADMIN: 'admin',
   MEMBER: 'member',
   NONE: 'none',
 });
@@ -24,7 +23,6 @@ export const WORLD_ACTIONS = Object.freeze({
 
 function resolveWorldRole({ isOwner = false, isAdmin = false, isMember = false } = {}) {
   if (isOwner) return WORLD_ROLES.OWNER;
-  if (isAdmin) return WORLD_ROLES.ADMIN;
   if (isMember) return WORLD_ROLES.MEMBER;
   return WORLD_ROLES.NONE;
 }
@@ -34,12 +32,12 @@ function resolveActionRequirement(action) {
     case WORLD_ACTIONS.VIEW_MANAGEMENT:
     case WORLD_ACTIONS.MANAGE_WORLD:
     case WORLD_ACTIONS.BROADCAST:
+    case WORLD_ACTIONS.CHANGE_ENABLED_STATE:
       return {
-        allowedRoles: [WORLD_ROLES.OWNER, WORLD_ROLES.ADMIN],
-        reason: 'management_role_required',
+        allowedRoles: [WORLD_ROLES.OWNER],
+        reason: 'owner_role_required',
       };
     case WORLD_ACTIONS.MANAGE_WORLD_ROLES:
-    case WORLD_ACTIONS.CHANGE_ENABLED_STATE:
       return {
         allowedRoles: [WORLD_ROLES.OWNER],
         reason: 'owner_role_required',

package/src/product-shell/worlds/world-routes.js

@@ -1,7 +1,6 @@
 import { authenticateAppTokenRequest, resolveAuthenticatedAgentId } from '../../lib/http-auth.js';
 import {
   buildCandidateDeliverySummary,
-  buildRequiredFieldExplanation,
   buildResolvedWorldJoinOrchestration,
   buildWorldSelectionPrompt,
 } from '../contracts/world-orchestration.js';
@@ -103,7 +102,7 @@ export function registerWorldRoutes(
     searchService,
     worldBroadcastService,
     worldAdminService,
-    sessionOrchestrator,
+    worldConversationOrchestrator,
   },
 ) {
   function resolveAgentIdentity(req, res, { providedAgentId = null, fieldName = 'agentId', required = true } = {}) {
@@ -175,17 +174,8 @@ export function registerWorldRoutes(
     try {
       const result = await worldAdminService.createWorld({
         ownerAgentId,
-        adminAgentIds: req.body?.adminAgentIds,
-        eligibility: req.body?.eligibility,
-        broadcast: req.body?.broadcast,
         displayName: req.body?.displayName,
-        summary: req.body?.summary,
-        description: req.body?.description,
-        entryProfileSchema: req.body?.entryProfileSchema,
-        interactionRules: req.body?.interactionRules,
-        prohibitedRules: req.body?.prohibitedRules,
-        ratingRules: req.body?.ratingRules,
-        sessionTemplate: req.body?.sessionTemplate,
+        worldContextText: req.body?.worldContextText,
         enabled: req.body?.enabled,
       });
       res.status(201).json(result);
@@ -197,12 +187,7 @@ export function registerWorldRoutes(
   app.get('/v1/worlds/:worldId', (req, res) => {
     try {
       const detail = worldService.describeWorldDetail(req.params.worldId);
-      const world = detail.world;
-      res.json({
-        ...detail,
-        matching: matchmakingService.describeStrategy(world.worldId),
-        requiredFieldExplanation: buildRequiredFieldExplanation(detail),
-      });
+      res.json(detail);
     } catch (error) {
       sendWorldError(res, error);
     }
@@ -269,19 +254,6 @@ export function registerWorldRoutes(
     }
   });
 
-  app.post('/v1/worlds/:worldId/join-check', (req, res) => {
-    try {
-      const result = membershipService.evaluateJoin({
-        worldId: req.params.worldId,
-        profile: req.body?.profile,
-        maxFieldsPerStep: req.body?.maxFieldsPerStep,
-      });
-      res.status(result.accepted ? 200 : 422).json(result);
-    } catch (error) {
-      sendWorldError(res, error);
-    }
-  });
-
   app.post('/v1/worlds/:worldId/join', async (req, res) => {
     const agentId = resolveAgentIdentity(req, res, {
       providedAgentId: req.body?.agentId,
@@ -292,9 +264,7 @@ export function registerWorldRoutes(
       const result = await membershipService.joinWorld({
         worldId: req.params.worldId,
         agentId,
-        profile: req.body?.profile,
-        profileSnapshot: req.body?.profileSnapshot,
-        maxFieldsPerStep: req.body?.maxFieldsPerStep,
+        participantContextText: req.body?.participantContextText,
       });
       const worldDetail = worldService.describeWorldDetail(req.params.worldId);
       const candidateFeed = matchmakingService.listCandidateFeed({
@@ -357,7 +327,7 @@ export function registerWorldRoutes(
       const result = await membershipService.createMembership({
         worldId: req.params.worldId,
         agentId,
-        profileSnapshot: req.body?.profileSnapshot,
+        participantContextText: req.body?.participantContextText,
       });
       res.status(result.created ? 201 : 200).json(result.membership);
     } catch (error) {
@@ -365,11 +335,11 @@ export function registerWorldRoutes(
     }
   });
 
-  app.post('/v1/worlds/:worldId/session-preview', (req, res) => {
+  app.post('/v1/worlds/:worldId/conversation-preview', (req, res) => {
     try {
-      const result = sessionOrchestrator.previewSession({
+      const result = worldConversationOrchestrator.previewConversation({
         worldId: req.params.worldId,
-        sessionId: req.body?.sessionId,
+        conversationKey: req.body?.conversationKey,
       });
       res.json(result);
     } catch (error) {

package/src/product-shell/worlds/world-service.js

@@ -3,7 +3,7 @@ import {
   projectWorldCard,
   projectWorldDetail,
   projectJoinPlan,
-  projectSessionStartupContext,
+  projectConversationWorldContext,
 } from '../contracts/world-manifest.js';
 import { DEFAULT_WORLD_MANIFESTS } from '../catalog/default-world-catalog.js';
 
@@ -75,8 +75,8 @@ export function createWorldService({ worldCatalog = DEFAULT_WORLD_MANIFESTS, sto
     buildJoinPlan(worldId) {
       return projectJoinPlan(this.requireWorld(worldId));
     },
-    describeSessionStartupContext(worldId) {
-      return projectSessionStartupContext(this.requireWorld(worldId));
+    describeConversationWorldContext(worldId) {
+      return projectConversationWorldContext(this.requireWorld(worldId));
     },
     describeCatalog() {
       return {