@xfxstudio/claworld 0.2.5 → 0.2.7

package/src/product-shell/social/chat-request-service.js

@@ -1,4 +1,5 @@
 import { normalizeAgentProfile, resolveAgentDisplayName, resolveAgentVisibility } from '../../lib/agent-profile.js';
+import { normalizeChatRequestInput } from '../../lib/chat-request.js';
 import { createKickoffBrief, resolveStoredKickoffBrief } from '../../lib/relay/kickoff-text.js';
 import { WORLD_ACTIONS } from '../worlds/world-authorization.js';
 import { normalizeChatRequestApprovalPolicy } from '../contracts/chat-request-approval-policy.js';
@@ -198,6 +199,7 @@ function resolveAcceptNextAction(kickoff) {
   const kickoffStatus = kickoff?.status || 'skipped';
   if (kickoffStatus === 'established') return 'runtime_owns_live_conversation';
   if (kickoffStatus === 'sent') return 'wait_for_sender_opener_delivery';
+  if (kickoffStatus === 'kept_silent') return 'sender_kept_silent';
   if (kickoffStatus === 'failed') return 'backend_kickoff_failed';
   return 'chat_request_accepted_without_opening_message';
 }
@@ -280,6 +282,92 @@ function projectChatRequestOrigin(request = {}) {
   };
 }
 
+function hasConversationScope(conversation = null) {
+  return Boolean(conversation && typeof conversation === 'object' && !Array.isArray(conversation) && Object.keys(conversation).length > 0);
+}
+
+function resolveConversationLinkRequest(requests = [], conversation = {}) {
+  const conversationMeta = conversation?.meta && typeof conversation.meta === 'object' && !Array.isArray(conversation.meta)
+    ? conversation.meta
+    : {};
+  const approvalRequestId = normalizeText(conversationMeta.approvalRequestId, null);
+  if (approvalRequestId) {
+    return requests.find((request) => normalizeText(request.chatRequestId || request.requestId, null) === approvalRequestId) || null;
+  }
+
+  const conversationKey = normalizeText(conversation?.conversationKey, null);
+  if (!conversationKey) return null;
+
+  return requests.find((request) => {
+    const kickoff = request?.kickoff && typeof request.kickoff === 'object' && !Array.isArray(request.kickoff)
+      ? request.kickoff
+      : {};
+    return normalizeText(kickoff.conversationKey, null) === conversationKey
+      || normalizeText(request?.conversation?.conversationKey, null) === conversationKey;
+  }) || null;
+}
+
+function resolveInboxChatDirection(viewerAgentId, request = null) {
+  if (!request) return null;
+  if (viewerAgentId === request.fromAgentId) return 'outbound';
+  if (viewerAgentId === request.toAgentId) return 'inbound';
+  return 'related';
+}
+
+function resolveInboxChatCounterpartyAgentId(viewerAgentId, request = null, conversation = null) {
+  if (request) {
+    if (viewerAgentId === request.fromAgentId) return request.toAgentId;
+    if (viewerAgentId === request.toAgentId) return request.fromAgentId;
+  }
+
+  const participantIds = Array.isArray(conversation?.participantIds) ? conversation.participantIds : [];
+  return participantIds.find((participantId) => participantId && participantId !== viewerAgentId) || null;
+}
+
+function resolveInboxChatStatus(conversation = {}, request = null) {
+  const kickoffStatus = normalizeText(request?.kickoff?.status, null);
+  if (kickoffStatus === 'sent') return 'opening';
+  if (kickoffStatus === 'kept_silent') return 'silent';
+  if (kickoffStatus === 'failed') return 'kickoff_failed';
+  const conversationStatus = normalizeText(conversation?.status, 'active');
+  if (conversationStatus === 'active') return 'active';
+  if (conversationStatus === 'closed') return 'ended';
+  return conversationStatus;
+}
+
+function resolveInboxConversationWorldSummary(worldService, request = {}, conversation = {}) {
+  const requestContext = request?.requestContext && typeof request.requestContext === 'object' && !Array.isArray(request.requestContext)
+    ? request.requestContext
+    : {};
+  const requestConversation = request?.conversation && typeof request.conversation === 'object' && !Array.isArray(request.conversation)
+    ? request.conversation
+    : {};
+  const conversationMeta = conversation?.meta && typeof conversation.meta === 'object' && !Array.isArray(conversation.meta)
+    ? conversation.meta
+    : {};
+  const worldMeta = conversationMeta.world && typeof conversationMeta.world === 'object' && !Array.isArray(conversationMeta.world)
+    ? conversationMeta.world
+    : {};
+  const worldId = normalizeConversationWorldId(requestConversation.worldId)
+    || normalizeConversationWorldId(requestContext.conversation?.worldId)
+    || normalizeConversationWorldId(worldMeta.worldId)
+    || normalizeConversationWorldId(conversationMeta.worldId);
+
+  if (!worldId) {
+    return {
+      mode: 'direct',
+      worldId: null,
+      world: null,
+    };
+  }
+
+  return {
+    mode: 'world',
+    worldId,
+    world: projectWorldSummary(worldService, worldId),
+  };
+}
+
 export function createChatRequestService({
   store = null,
   relay = null,
@@ -349,8 +437,27 @@ export function createChatRequestService({
     };
   }
 
+  function projectChatInboxChat(conversation = {}, viewerAgentId = null, request = null) {
+    const direction = resolveInboxChatDirection(viewerAgentId, request);
+    const counterpartyAgentId = resolveInboxChatCounterpartyAgentId(viewerAgentId, request, conversation);
+
+    return {
+      chatRequestId: normalizeText(request?.chatRequestId || request?.requestId, null),
+      status: resolveInboxChatStatus(conversation, request),
+      ...(direction ? { direction } : {}),
+      createdAt: normalizeText(conversation.createdAt, normalizeText(request?.createdAt, null)),
+      updatedAt: normalizeText(conversation.updatedAt, null),
+      lastTurnAt: normalizeText(conversation.lastTurnAt, null),
+      conversationKey: normalizeText(conversation.conversationKey, null),
+      localSessionKey: normalizeText(conversation.sessionKey, null),
+      counterparty: projectAgent(assertStore(), counterpartyAgentId, presence),
+      conversation: resolveInboxConversationWorldSummary(worldService, request, conversation),
+    };
+  }
+
   return {
     projectChatRequest,
+    projectChatInboxChat,
     async syncApprovalPolicy({
       actorAgentId,
       credentialId = null,
@@ -388,6 +495,7 @@ export function createChatRequestService({
       openingMessage = null,
       openingPayload = null,
       worldId = null,
+      requestContext = null,
       origin = null,
       broadcast = null,
       source = 'chat_request',
@@ -398,29 +506,36 @@ export function createChatRequestService({
         throw createInvalidChatRequestError('chat_request_target_required', 'chat request target requires targetAgentId');
       }
       const targetAgent = requireAgent(normalizedTargetAgentId);
-      const normalizedWorldId = normalizeConversationWorldId(worldId);
+      const normalizedSource = normalizeText(source, 'chat_request');
+      const normalizedRequestInput = normalizeChatRequestInput({
+        requestContext,
+        source: normalizedSource,
+      });
+      const normalizedWorldId = normalizeConversationWorldId(worldId)
+        || normalizeConversationWorldId(normalizedRequestInput.conversation?.worldId);
       if (!targetAgent?.address) {
         throw createTargetAddressNotFoundError(normalizedTargetAgentId);
       }
-      const normalizedOpeningPayload = cloneJsonObject(openingPayload);
+      const normalizedOpeningPayload = cloneJsonObject(openingPayload) || cloneJsonObject(normalizedRequestInput.openingPayload);
       const normalizedKickoffBrief = createKickoffBrief({
         text: typeof kickoffBrief === 'object' && kickoffBrief !== null && !Array.isArray(kickoffBrief)
           ? kickoffBrief.text
-          : openingMessage,
+          : normalizeText(openingMessage, normalizeText(normalizedRequestInput.openingMessage, null)),
         payload: typeof kickoffBrief === 'object' && kickoffBrief !== null && !Array.isArray(kickoffBrief)
           ? kickoffBrief.payload
           : normalizedOpeningPayload,
         source: typeof kickoffBrief === 'object' && kickoffBrief !== null && !Array.isArray(kickoffBrief)
           ? kickoffBrief.source
-          : source === 'world_broadcast'
+          : normalizedSource === 'world_broadcast'
             ? 'world_broadcast_brief'
             : 'chat_request_brief',
       });
-      const normalizedOrigin = normalizeChatRequestOrigin(origin);
-      const normalizedBroadcast = normalizeChatRequestBroadcastMetadata(broadcast);
+      const normalizedOrigin = normalizeChatRequestOrigin(origin) || normalizeChatRequestOrigin(normalizedRequestInput.origin);
+      const normalizedBroadcast = normalizeChatRequestBroadcastMetadata(broadcast)
+        || normalizeChatRequestBroadcastMetadata(normalizedRequestInput.broadcast);
       if (normalizedWorldId) {
         worldService?.requireWorld?.(normalizedWorldId);
-        if (normalizeText(source, 'chat_request') !== 'world_broadcast') {
+        if (normalizedSource !== 'world_broadcast') {
           const authorization = worldAuthorizationService.evaluateWorldAction({
             worldId: normalizedWorldId,
             actorAgentId: fromAgentId,
@@ -444,9 +559,10 @@ export function createChatRequestService({
         conversation: {
           ...(normalizedWorldId ? { worldId: normalizedWorldId } : {}),
         },
+        requestContext: cloneJsonObject(requestContext),
         origin: normalizedOrigin,
         broadcast: normalizedBroadcast,
-        source: normalizeText(source, 'chat_request'),
+        source: normalizedSource,
       });
       if (result.status < 200 || result.status >= 300) {
         throw createRelayResponseError(result, 'chat_request_create_failed');
@@ -494,23 +610,55 @@ export function createChatRequestService({
       };
     },
 
-    listChatRequests({ agentId, direction = null } = {}) {
+    listChatInbox({ agentId, direction = null } = {}) {
       requireAgent(agentId);
       const normalizedDirection = normalizeDirection(direction);
-      let items = assertStore().listChatRequests ? assertStore().listChatRequests() : [];
-      items = items.filter((request) => request.status === 'pending');
-      items = items.filter((request) => request.fromAgentId === agentId || request.toAgentId === agentId);
+      let requests = assertStore().listChatRequests ? assertStore().listChatRequests() : [];
+      requests = requests.filter((request) => request.fromAgentId === agentId || request.toAgentId === agentId);
       if (normalizedDirection === 'inbound') {
-        items = items.filter((request) => request.toAgentId === agentId);
+        requests = requests.filter((request) => request.toAgentId === agentId);
       } else if (normalizedDirection === 'outbound') {
-        items = items.filter((request) => request.fromAgentId === agentId);
+        requests = requests.filter((request) => request.fromAgentId === agentId);
       }
 
+      const pendingRequests = sortByRecency(
+        requests.filter((request) => request.status === 'pending'),
+        'createdAt',
+      ).map((request) => projectChatRequest(request, agentId));
+
+      const conversations = assertStore().listConversations
+        ? assertStore().listConversations({ participantId: agentId })
+        : [];
+      const chats = sortByRecency(
+        conversations
+          .map((conversation) => {
+            const linkedRequest = resolveConversationLinkRequest(requests, conversation);
+            if (!linkedRequest && !normalizeText(conversation?.meta?.approvalRequestId, null)) return null;
+            const projected = projectChatInboxChat(conversation, agentId, linkedRequest);
+            if (!projected) return null;
+            if (normalizedDirection && projected.direction !== normalizedDirection) return null;
+            return projected;
+          })
+          .filter(Boolean),
+        'lastTurnAt',
+        'updatedAt',
+        'createdAt',
+      );
+
       return {
-        items: sortByRecency(items, 'createdAt').map((request) => projectChatRequest(request, agentId)),
+        counts: {
+          pendingRequestCount: pendingRequests.length,
+          chatCount: chats.length,
+        },
+        pendingRequests,
+        chats,
       };
     },
 
+    listChatRequests({ agentId, direction = null } = {}) {
+      return this.listChatInbox({ agentId, direction });
+    },
+
     async acceptChatRequest(chatRequestId, { actorAgentId } = {}) {
       requireAgent(actorAgentId);
       const normalizedChatRequestId = normalizeText(chatRequestId, null);
@@ -534,5 +682,27 @@ export function createChatRequestService({
         nextAction: resolveAcceptNextAction(kickoff),
       };
     },
+
+    async rejectChatRequest(chatRequestId, { actorAgentId } = {}) {
+      requireAgent(actorAgentId);
+      const normalizedChatRequestId = normalizeText(chatRequestId, null);
+      if (!normalizedChatRequestId) {
+        throw createInvalidChatRequestError('chat_request_id_required', 'chatRequestId is required');
+      }
+
+      const result = await assertRelay('rejectChatRequest').rejectChatRequest(normalizedChatRequestId, {
+        actorAgentId,
+      });
+      if (result.status < 200 || result.status >= 300) {
+        throw createRelayResponseError(result, 'chat_request_reject_failed');
+      }
+
+      return {
+        status: 'rejected',
+        verdict: 'manual_reject',
+        chatRequest: projectChatRequest(result.body || {}, actorAgentId),
+        nextAction: 'request_rejected_by_peer',
+      };
+    },
   };
 }

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

@@ -12,36 +12,6 @@ function normalizeBoolean(value, fallback = false) {
   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 summarizeWorldContextText(worldContextText, fallback = null) {
   const normalized = normalizeText(worldContextText, null);
   if (!normalized) return fallback;
@@ -78,7 +48,7 @@ function createWorldActionNotAllowedError({
   worldId,
   agentId,
   action,
-  actorRole = WORLD_ROLES.NONE,
+  actorRole = null,
   allowedRoles = [],
 } = {}) {
   const error = new Error(`world_action_not_allowed:${action}:${worldId}:${agentId}`);
@@ -87,7 +57,6 @@ function createWorldActionNotAllowedError({
   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 = {
@@ -125,7 +94,7 @@ function normalizeAgentId(agentId) {
 
 function normalizeWorldRole(worldRole, fallback = null) {
   const normalized = normalizeText(worldRole, fallback);
-  return [WORLD_ROLES.OWNER, WORLD_ROLES.ADMIN, WORLD_ROLES.MEMBER].includes(normalized) ? normalized : fallback;
+  return [WORLD_ROLES.OWNER, WORLD_ROLES.MEMBER].includes(normalized) ? normalized : fallback;
 }
 
 function buildDefaultEntryProfileField() {
@@ -175,60 +144,39 @@ function buildConversationTemplate(interactionRules, prohibitedRules, { existing
   };
 }
 
-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,
   displayName,
   summary,
-  description,
-  interactionRules,
-  prohibitedRules,
-  ratingRules,
   worldContextText = null,
   enabled = false,
   status = null,
-  schemaVersion = 1,
   existingMetrics = null,
-  existingConversationTemplate = null,
 } = {}) {
   const resolvedStatus = status || (enabled ? 'enabled' : 'draft');
   const participantContextField = buildDefaultEntryProfileField();
+  const resolvedWorldContextText = buildWorldContextText({
+    worldId,
+    displayName,
+    summary,
+    worldContextText,
+    interactionRules: null,
+    prohibitedRules: null,
+  });
 
   return {
     worldId,
     slug: slugify(displayName, worldId),
     displayName,
     summary,
-    description,
+    description: resolvedWorldContextText,
     category: 'ugc',
     lifecycle: 'creator_managed',
     tags: ['ugc', 'creator-managed'],
-    interactionRules,
-    prohibitedRules,
-    ratingRules,
-    worldContextText: buildWorldContextText({
-      worldId,
-      displayName,
-      summary,
-      worldContextText,
-      interactionRules,
-      prohibitedRules,
-      ratingRules,
-    }),
-    roles: [],
+    interactionRules: null,
+    prohibitedRules: null,
+    worldContextText: resolvedWorldContextText,
     joinSchema: {
       requiredFields: [participantContextField],
       optionalFields: [],
@@ -236,16 +184,12 @@ function buildWorldRecord({
     },
     searchSchema: buildSearchSchema(),
     matching: buildMatchingStrategy(),
-    conversationTemplate: buildConversationTemplate(interactionRules, prohibitedRules, {
-      existingConversationTemplate,
-    }),
-    resultContract: buildResultContract(worldId, ratingRules),
+    conversationTemplate: buildConversationTemplate(null, null),
     meta: {
       status: resolvedStatus === 'enabled' ? 'creator_enabled' : 'creator_draft',
       persistence: 'store',
     },
     creatorAgentId,
-    adminAgentIds: [],
     eligibility: 'active',
     broadcast: {
       enabled: false,
@@ -255,7 +199,7 @@ function buildWorldRecord({
     },
     status: resolvedStatus,
     enabled,
-    schemaVersion,
+    schemaVersion: 1,
     metrics: existingMetrics || {
       totalConversationCount: 0,
     },
@@ -339,29 +283,18 @@ export function createWorldAdminService({ worldService, worldAuthorizationServic
     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 } = {}) {
+  function requireWorldOwner({ worldId, actorAgentId } = {}) {
     const authorization = worldAuthorizationService.evaluateWorldAction({
       worldId,
       actorAgentId,
-      action,
+      action: WORLD_ACTIONS.MANAGE_WORLD,
       includeDisabled: true,
     });
     if (!authorization.allowed) {
       throw createWorldActionNotAllowedError({
         worldId: authorization.world.worldId,
         agentId: actorAgentId,
-        action,
+        action: WORLD_ACTIONS.MANAGE_WORLD,
         actorRole: authorization.worldRole,
         allowedRoles: authorization.allowedRoles,
       });
@@ -395,10 +328,6 @@ export function createWorldAdminService({ worldService, worldAuthorizationServic
         creatorAgentId: resolvedOwnerAgentId,
         displayName: resolvedDisplayName,
         summary: summarizeWorldContextText(resolvedWorldContextText, resolvedDisplayName),
-        description: resolvedWorldContextText,
-        interactionRules: null,
-        prohibitedRules: null,
-        ratingRules: null,
         worldContextText: resolvedWorldContextText,
         enabled: normalizeBoolean(enabled, false),
       });
@@ -413,8 +342,13 @@ export function createWorldAdminService({ worldService, worldAuthorizationServic
     listManagedWorlds({ actorAgentId, creatorAgentId, includeDisabled = true } = {}) {
       const storeBacked = assertStore();
       const resolvedActorAgentId = assertActorAgent(actorAgentId || creatorAgentId);
-      return worldAuthorizationService
-        .listManagedWorlds({ actorAgentId: resolvedActorAgentId, includeDisabled })
+      return worldService
+        .listOwnedWorlds({ creatorAgentId: resolvedActorAgentId, includeDisabled })
+        .map((world) => worldAuthorizationService.resolveWorldActorContext({
+          worldId: world.worldId,
+          actorAgentId: resolvedActorAgentId,
+          includeDisabled,
+        }))
         .map((context) => projectManagedWorldSummary(storeBacked, context.world, {
           worldRole: context.worldRole,
         }));
@@ -425,10 +359,9 @@ export function createWorldAdminService({ worldService, worldAuthorizationServic
     getManagedWorld({ actorAgentId, creatorAgentId, worldId } = {}) {
       const storeBacked = assertStore();
       const resolvedActorAgentId = assertActorAgent(actorAgentId || creatorAgentId);
-      const authorization = requireWorldAction({
+      const authorization = requireWorldOwner({
         worldId,
         actorAgentId: resolvedActorAgentId,
-        action: WORLD_ACTIONS.VIEW_MANAGEMENT,
       });
       return projectManagedWorld(storeBacked, authorization.world, {
         worldRole: authorization.worldRole,
@@ -439,25 +372,10 @@ export function createWorldAdminService({ worldService, worldAuthorizationServic
       const resolvedActorAgentId = assertActorAgent(actorAgentId || creatorAgentId);
       const hasChanges = changes && typeof changes === 'object' && !Array.isArray(changes);
 
-      let authorization = requireWorldAction({
+      const authorization = requireWorldOwner({
         worldId,
         actorAgentId: resolvedActorAgentId,
-        action: WORLD_ACTIONS.VIEW_MANAGEMENT,
       });
-      if (hasManageWorldChanges(changes)) {
-        authorization = requireWorldAction({
-          worldId,
-          actorAgentId: resolvedActorAgentId,
-          action: WORLD_ACTIONS.MANAGE_WORLD,
-        });
-      }
-      if (enabled != null) {
-        authorization = requireWorldAction({
-          worldId,
-          actorAgentId: resolvedActorAgentId,
-          action: WORLD_ACTIONS.CHANGE_ENABLED_STATE,
-        });
-      }
 
       const existingWorld = authorization.world;
       if (!hasChanges && enabled == null) {
@@ -466,7 +384,6 @@ export function createWorldAdminService({ worldService, worldAuthorizationServic
         });
       }
 
-      let nextSchemaVersion = Number(existingWorld.schemaVersion || 1);
       let nextRecord = existingWorld;
 
       if (hasChanges) {
@@ -479,18 +396,12 @@ export function createWorldAdminService({ worldService, worldAuthorizationServic
           creatorAgentId: existingWorld.creatorAgentId,
           displayName: nextDisplayName,
           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
             : (normalizeBoolean(enabled, false) ? 'enabled' : 'disabled'),
-          schemaVersion: nextSchemaVersion,
           existingMetrics: existingWorld.metrics || null,
-          existingConversationTemplate: existingWorld.conversationTemplate || null,
         });
       } else if (enabled != null) {
         nextRecord = {
@@ -505,9 +416,6 @@ export function createWorldAdminService({ worldService, worldAuthorizationServic
       }
 
       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,

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

@@ -7,13 +7,11 @@ function normalizeText(value, fallback = null) {
 export const WORLD_ROLES = Object.freeze({
   OWNER: 'owner',
   MEMBER: 'member',
-  NONE: 'none',
 });
 
 export const WORLD_ACTIONS = Object.freeze({
   VIEW_MANAGEMENT: 'view_world_management',
   MANAGE_WORLD: 'manage_world',
-  MANAGE_WORLD_ROLES: 'manage_world_roles',
   CHANGE_ENABLED_STATE: 'change_world_enabled_state',
   BROADCAST: 'broadcast_world',
   SEARCH: 'search_world',
@@ -21,10 +19,22 @@ export const WORLD_ACTIONS = Object.freeze({
   CREATE_CHAT_REQUEST: 'create_world_chat_request',
 });
 
-function resolveWorldRole({ isOwner = false, isAdmin = false, isMember = false } = {}) {
+function resolveWorldRole({ isOwner = false, isMember = false } = {}) {
   if (isOwner) return WORLD_ROLES.OWNER;
   if (isMember) return WORLD_ROLES.MEMBER;
-  return WORLD_ROLES.NONE;
+  return null;
+}
+
+function resolveEffectiveRoles({ isOwner = false, isMember = false } = {}) {
+  const roles = [];
+  if (isOwner) {
+    roles.push(WORLD_ROLES.OWNER);
+    // World owners should retain member-scoped capabilities for worlds they are actively in.
+    if (isMember) roles.push(WORLD_ROLES.MEMBER);
+    return roles;
+  }
+  if (isMember) roles.push(WORLD_ROLES.MEMBER);
+  return roles;
 }
 
 function resolveActionRequirement(action) {
@@ -37,11 +47,6 @@ function resolveActionRequirement(action) {
         allowedRoles: [WORLD_ROLES.OWNER],
         reason: 'owner_role_required',
       };
-    case WORLD_ACTIONS.MANAGE_WORLD_ROLES:
-      return {
-        allowedRoles: [WORLD_ROLES.OWNER],
-        reason: 'owner_role_required',
-      };
     case WORLD_ACTIONS.SEARCH:
     case WORLD_ACTIONS.VIEW_CANDIDATE_FEED:
     case WORLD_ACTIONS.CREATE_CHAT_REQUEST:
@@ -77,22 +82,20 @@ export function createWorldAuthorizationService({ worldService, membershipServic
       ? resolveMembership(world.worldId, normalizedActorAgentId, { includeDisabled })
       : null;
     const isOwner = normalizedActorAgentId != null && normalizedActorAgentId === world.creatorAgentId;
-    const isAdmin = normalizedActorAgentId != null
-      && Array.isArray(world.adminAgentIds)
-      && world.adminAgentIds.includes(normalizedActorAgentId);
     const isMember = membership?.status === 'active';
-    const worldRole = resolveWorldRole({ isOwner, isAdmin, isMember });
+    const worldRole = resolveWorldRole({ isOwner, isMember });
+    const effectiveRoles = resolveEffectiveRoles({ isOwner, isMember });
 
     return {
       world,
       actorAgentId: normalizedActorAgentId,
       worldRole,
-      managementRole: isOwner ? WORLD_ROLES.OWNER : isAdmin ? WORLD_ROLES.ADMIN : null,
+      effectiveRoles,
+      managementRole: isOwner ? WORLD_ROLES.OWNER : null,
       membership,
       membershipStatus: membership?.status || null,
       roles: {
         owner: isOwner,
-        admin: isAdmin,
         member: isMember,
       },
     };
@@ -111,7 +114,7 @@ export function createWorldAuthorizationService({ worldService, membershipServic
         includeDisabled,
       });
       const requirement = resolveActionRequirement(action);
-      const allowed = requirement.allowedRoles.includes(actor.worldRole);
+      const allowed = actor.effectiveRoles.some((role) => requirement.allowedRoles.includes(role));
 
       return {
         ...actor,
@@ -125,7 +128,7 @@ export function createWorldAuthorizationService({ worldService, membershipServic
 
     listManagedWorlds({ actorAgentId, includeDisabled = true } = {}) {
       return worldService
-        .listCustomWorlds({ includeDisabled })
+        .listOwnedWorlds({ creatorAgentId: actorAgentId, includeDisabled })
         .map((world) => resolveWorldActorContextForWorld(world, actorAgentId, { includeDisabled }))
         .filter((context) => context.managementRole != null);
     },