@xfxstudio/claworld 0.1.0

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

@@ -0,0 +1,705 @@
+import { WORLD_ACTIONS, WORLD_ROLES } from './world-authorization.js';
+
+function normalizeText(value, fallback = null) {
+  if (value == null) return fallback;
+  const normalized = String(value).trim();
+  return normalized || fallback;
+}
+
+function normalizeBoolean(value, fallback = false) {
+  if (typeof value === 'boolean') return value;
+  return fallback;
+}
+
+function normalizeStringList(values = []) {
+  if (!Array.isArray(values)) return [];
+  return [...new Set(values.map((value) => normalizeText(value, null)).filter(Boolean))];
+}
+
+function normalizePositiveInteger(value, fallback = null) {
+  const parsed = Number(value);
+  if (!Number.isFinite(parsed) || parsed <= 0) return fallback;
+  return Math.max(1, Math.trunc(parsed));
+}
+
+function normalizeWorldEligibility(value, fallback = 'active') {
+  const normalized = normalizeText(value, fallback);
+  if (normalized === 'joined') return 'joined';
+  return 'active';
+}
+
+function normalizeBroadcastAudience(value, fallback = 'members') {
+  const normalized = normalizeText(value, fallback);
+  if (normalized === 'admins') return 'admins';
+  if (normalized === 'admins_and_owner') return 'admins_and_owner';
+  return 'members';
+}
+
+function normalizeBroadcastReplyPolicy(value, fallback = 'zero') {
+  const normalized = normalizeText(value, fallback);
+  if (normalized === 'at_most_one') return 'at_most_one';
+  return 'zero';
+}
+
+function slugify(value, fallback = 'world') {
+  const normalized = normalizeText(value, fallback)
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, '-')
+    .replace(/^-+|-+$/g, '');
+  return normalized || fallback;
+}
+
+function createConfigurationError() {
+  const error = new Error('world_store_unavailable');
+  error.code = 'world_store_unavailable';
+  error.status = 500;
+  return error;
+}
+
+function createAgentNotFoundError(agentId) {
+  const error = new Error(`agent_not_found:${agentId}`);
+  error.code = 'agent_not_found';
+  error.status = 404;
+  return error;
+}
+
+function createWorldActionNotAllowedError({
+  worldId,
+  agentId,
+  action,
+  actorRole = WORLD_ROLES.NONE,
+  allowedRoles = [],
+} = {}) {
+  const error = new Error(`world_action_not_allowed:${action}:${worldId}:${agentId}`);
+  error.code = 'world_action_not_allowed';
+  error.status = 403;
+  const messageByAction = {
+    [WORLD_ACTIONS.VIEW_MANAGEMENT]: 'agent does not have permission to access world management',
+    [WORLD_ACTIONS.MANAGE_WORLD]: 'agent does not have permission to manage this world',
+    [WORLD_ACTIONS.MANAGE_WORLD_ROLES]: 'only the world owner can manage world admins',
+    [WORLD_ACTIONS.CHANGE_ENABLED_STATE]: 'only the world owner can enable or disable this world',
+  };
+  error.responseBody = {
+    error: error.code,
+    message: messageByAction[action] || 'agent does not have permission to manage this world',
+    worldId,
+    agentId,
+    action,
+    actorRole,
+    allowedRoles,
+  };
+  return error;
+}
+
+function createInvalidWorldRequestError(fieldId, message = `${fieldId} is required`) {
+  const error = new Error(`invalid_world_request:${fieldId}`);
+  error.code = 'invalid_world_request';
+  error.status = 400;
+  error.responseBody = {
+    error: error.code,
+    message: 'world request is invalid',
+    fieldErrors: [
+      {
+        fieldId,
+        message,
+      },
+    ],
+  };
+  return error;
+}
+
+function normalizeAgentId(agentId) {
+  return normalizeText(agentId, null);
+}
+
+function normalizeWorldRole(worldRole, fallback = null) {
+  const normalized = normalizeText(worldRole, fallback);
+  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');
+  }
+
+  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),
+  };
+}
+
+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) {
+  return {
+    mode: 'profile_overlap_search',
+    inputFieldIds: entryProfileSchema.searchableFieldIds,
+    summary: 'Search active online members by overlap on the world profile fields chosen by the world creator.',
+    onlineOnly: true,
+    defaultLimit: 10,
+  };
+}
+
+function buildMatchingStrategy(entryProfileSchema) {
+  return {
+    mode: 'profile_overlap',
+    cadence: 'on_demand',
+    strategySummary:
+      `Rank world members by overlap on ${entryProfileSchema.searchableFieldIds.join(', ')} before opening a conversation.`,
+    candidateSources: ['active_memberships'],
+  };
+}
+
+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 } = {}) {
+  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.',
+    },
+    worldRules: {
+      openingText: interactionRules,
+      turnMessageRules: Array.isArray(existingSessionTemplate?.worldRules?.turnMessageRules)
+        ? existingSessionTemplate.worldRules.turnMessageRules
+        : [],
+      convergence: existingSessionTemplate?.worldRules?.convergence || {},
+      stateChangeMessages: existingSessionTemplate?.worldRules?.stateChangeMessages || {},
+    },
+  };
+}
+
+function buildResultContract(worldId, ratingRules) {
+  return {
+    schemaId: `${worldId}.result.v1`,
+    outputs: ['rating', 'recommendation', 'notes'],
+    successCriteria: [ratingRules || 'Each side gives an explicit 1 to 10 rating.'],
+    exampleSignals: {
+      intentSignals: [],
+      conversationSignals: [],
+      agentSignals: [],
+    },
+  };
+}
+
+function buildWorldRecord({
+  worldId,
+  creatorAgentId,
+  adminAgentIds = [],
+  eligibility = 'active',
+  broadcast = undefined,
+  displayName,
+  summary,
+  description,
+  interactionRules,
+  prohibitedRules,
+  ratingRules,
+  entryProfileSchema,
+  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 });
+
+  return {
+    worldId,
+    slug: slugify(displayName, worldId),
+    displayName,
+    summary,
+    description,
+    category: 'ugc',
+    lifecycle: 'creator_managed',
+    tags: ['ugc', 'creator-managed'],
+    interactionRules,
+    prohibitedRules,
+    ratingRules,
+    roles: [],
+    joinSchema: {
+      requiredFields: entryProfileSchema.requiredFields,
+      optionalFields: entryProfileSchema.optionalFields,
+      hints: [],
+    },
+    searchSchema: buildSearchSchema(entryProfileSchema),
+    matching: buildMatchingStrategy(entryProfileSchema),
+    sessionTemplate: buildSessionTemplate(interactionRules, prohibitedRules, {
+      maxTurns: resolvedMaxTurns,
+      existingSessionTemplate,
+    }),
+    resultContract: buildResultContract(worldId, ratingRules),
+    meta: {
+      status: resolvedStatus === 'enabled' ? 'creator_enabled' : 'creator_draft',
+      persistence: 'store',
+    },
+    creatorAgentId,
+    adminAgentIds,
+    eligibility: resolvedEligibility,
+    broadcast: resolvedBroadcast,
+    status: resolvedStatus,
+    enabled,
+    schemaVersion,
+    metrics: existingMetrics || {
+      totalConversationCount: 0,
+    },
+  };
+}
+
+function projectEntryProfileSchema(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 : []);
+
+  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),
+    })),
+  };
+}
+
+function projectWorldStats(store, world = {}) {
+  const totalParticipants = store.countMemberships({ worldId: world.worldId });
+  const activeParticipants = store.countMemberships({ worldId: world.worldId, status: 'active' });
+  return {
+    totalParticipants,
+    activeParticipants,
+    totalConversationCount: Number(world.metrics?.totalConversationCount || 0),
+  };
+}
+
+function projectManagedWorldSummary(store, world = {}, { worldRole = null } = {}) {
+  return {
+    worldId: world.worldId,
+    displayName: world.displayName,
+    summary: world.summary,
+    enabled: world.enabled === true,
+    status: world.status || 'draft',
+    worldRole: normalizeWorldRole(worldRole, null),
+    createdAt: world.createdAt || null,
+    updatedAt: world.updatedAt || null,
+    stats: projectWorldStats(store, world),
+  };
+}
+
+function projectManagedWorld(store, world = {}, { worldRole = null } = {}) {
+  return {
+    worldId: world.worldId,
+    displayName: world.displayName,
+    summary: world.summary,
+    description: world.description,
+    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,
+    stats: projectWorldStats(store, world),
+  };
+}
+
+function buildWorldId(displayName, existingIds = []) {
+  const base = `ugc-${slugify(displayName, 'world')}`;
+  if (!existingIds.includes(base)) return base;
+
+  let counter = 2;
+  while (existingIds.includes(`${base}-${counter}`)) {
+    counter += 1;
+  }
+  return `${base}-${counter}`;
+}
+
+export function createWorldAdminService({ worldService, worldAuthorizationService, store = null } = {}) {
+  function assertStore() {
+    if (!store) throw createConfigurationError();
+    return store;
+  }
+
+  function assertActorAgent(agentId) {
+    const actorAgentId = normalizeAgentId(agentId);
+    if (!actorAgentId) throw createInvalidWorldRequestError('agentId', 'agentId is required');
+    const agent = assertStore().getAgent(actorAgentId);
+    if (!agent) throw createAgentNotFoundError(actorAgentId);
+    return actorAgentId;
+  }
+
+  async function markMembershipsStale(worldId) {
+    const membershipStore = assertStore();
+    const memberships = membershipStore.listMemberships({ worldId });
+    for (const membership of memberships) {
+      if (!['joined', 'active'].includes(membership.status)) continue;
+      await membershipStore.updateMembership(membership.membershipId, {
+        status: 'stale_profile',
+      });
+    }
+  }
+
+  function requireWorldAction({ worldId, actorAgentId, action } = {}) {
+    const authorization = worldAuthorizationService.evaluateWorldAction({
+      worldId,
+      actorAgentId,
+      action,
+      includeDisabled: true,
+    });
+    if (!authorization.allowed) {
+      throw createWorldActionNotAllowedError({
+        worldId: authorization.world.worldId,
+        agentId: actorAgentId,
+        action,
+        actorRole: authorization.worldRole,
+        allowedRoles: authorization.allowedRoles,
+      });
+    }
+    return authorization;
+  }
+
+  function hasManageWorldChanges(changes = null) {
+    if (!changes || typeof changes !== 'object' || Array.isArray(changes)) return false;
+    return Object.keys(changes).some((fieldId) => fieldId !== 'adminAgentIds');
+  }
+
+  return {
+    async createWorld({
+      ownerAgentId,
+      creatorAgentId,
+      adminAgentIds = [],
+      eligibility = 'active',
+      broadcast = undefined,
+      displayName,
+      summary,
+      description,
+      entryProfileSchema,
+      interactionRules,
+      prohibitedRules,
+      ratingRules,
+      sessionTemplate,
+      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 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,
+        enabled: normalizeBoolean(enabled, false),
+      });
+
+      const created = await storeBacked.createWorldConfig(worldRecord);
+      const normalizedWorld = worldService.requireWorld(created.worldId, { includeDisabled: true });
+
+      return projectManagedWorld(storeBacked, normalizedWorld, {
+        worldRole: WORLD_ROLES.OWNER,
+      });
+    },
+    listManagedWorlds({ actorAgentId, creatorAgentId, includeDisabled = true } = {}) {
+      const storeBacked = assertStore();
+      const resolvedActorAgentId = assertActorAgent(actorAgentId || creatorAgentId);
+      return worldAuthorizationService
+        .listManagedWorlds({ actorAgentId: resolvedActorAgentId, includeDisabled })
+        .map((context) => projectManagedWorldSummary(storeBacked, context.world, {
+          worldRole: context.worldRole,
+        }));
+    },
+    listOwnedWorlds(input = {}) {
+      return this.listManagedWorlds(input);
+    },
+    getManagedWorld({ actorAgentId, creatorAgentId, worldId } = {}) {
+      const storeBacked = assertStore();
+      const resolvedActorAgentId = assertActorAgent(actorAgentId || creatorAgentId);
+      const authorization = requireWorldAction({
+        worldId,
+        actorAgentId: resolvedActorAgentId,
+        action: WORLD_ACTIONS.VIEW_MANAGEMENT,
+      });
+      return projectManagedWorld(storeBacked, authorization.world, {
+        worldRole: authorization.worldRole,
+      });
+    },
+    async manageWorld({ actorAgentId, creatorAgentId, worldId, changes = null, enabled = null } = {}) {
+      const storeBacked = assertStore();
+      const resolvedActorAgentId = assertActorAgent(actorAgentId || creatorAgentId);
+      const hasChanges = changes && typeof changes === 'object' && !Array.isArray(changes);
+
+      let authorization = requireWorldAction({
+        worldId,
+        actorAgentId: resolvedActorAgentId,
+        action: WORLD_ACTIONS.VIEW_MANAGEMENT,
+      });
+      if (hasManageWorldChanges(changes)) {
+        authorization = requireWorldAction({
+          worldId,
+          actorAgentId: resolvedActorAgentId,
+          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,
+          actorAgentId: resolvedActorAgentId,
+          action: WORLD_ACTIONS.CHANGE_ENABLED_STATE,
+        });
+      }
+
+      const existingWorld = authorization.world;
+      if (!hasChanges && enabled == null) {
+        return projectManagedWorld(storeBacked, existingWorld, {
+          worldRole: authorization.worldRole,
+        });
+      }
+
+      let nextSchemaVersion = Number(existingWorld.schemaVersion || 1);
+      let nextRecord = existingWorld;
+
+      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;
+        }
+
+        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,
+          enabled: enabled == null ? existingWorld.enabled === true : normalizeBoolean(enabled, false),
+          status: enabled == null
+            ? existingWorld.status
+            : (normalizeBoolean(enabled, false) ? 'enabled' : 'disabled'),
+          schemaVersion: nextSchemaVersion,
+          existingMetrics: existingWorld.metrics || null,
+        });
+      } else if (enabled != null) {
+        nextRecord = {
+          ...existingWorld,
+          enabled: normalizeBoolean(enabled, false),
+          status: normalizeBoolean(enabled, false) ? 'enabled' : 'disabled',
+          meta: {
+            ...(existingWorld.meta || {}),
+            status: normalizeBoolean(enabled, false) ? 'creator_enabled' : 'creator_disabled',
+          },
+        };
+      }
+
+      const updated = await storeBacked.updateWorldConfig(existingWorld.worldId, nextRecord);
+      if (nextSchemaVersion !== Number(existingWorld.schemaVersion || 1)) {
+        await markMembershipsStale(existingWorld.worldId);
+      }
+      const normalizedWorld = worldService.requireWorld(updated.worldId, { includeDisabled: true });
+      return projectManagedWorld(storeBacked, normalizedWorld, {
+        worldRole: authorization.worldRole,
+      });
+    },
+  };
+}