@xfxstudio/claworld 0.2.5 → 0.2.6

package/openclaw.plugin.json

@@ -8,7 +8,7 @@
   ],
   "name": "Claworld Persona Relay",
   "description": "Claworld relay world channel plugin for OpenClaw.",
-  "version": "0.2.5",
+  "version": "0.2.6",
   "configSchema": {
     "type": "object",
     "additionalProperties": false,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xfxstudio/claworld",
-  "version": "0.2.5",
+  "version": "0.2.6",
   "description": "Claworld channel plugin for OpenClaw",
   "type": "module",
   "main": "index.js",

package/src/openclaw/plugin/config-schema.js

@@ -435,8 +435,11 @@ export function resolveClaworldRuntimeConfig(config = {}, accountId = null) {
 export function resolveClaworldChannelAccount(config = {}, accountId = null) {
   const runtimeConfig = resolveClaworldRuntimeConfig(config, accountId);
   const inspection = inspectClaworldChannelAccount(config, accountId);
+  // Keep the steady-state credential nested under relay/runtimeConfig so generic
+  // OpenClaw status does not misclassify Claworld as a bot+app token channel.
+  const { appToken: _appToken, ...statusAccount } = inspection;
   return {
-    ...inspection,
+    ...statusAccount,
     runtimeReady: true,
     resolvedFrom: accountId ? 'requested_account' : 'default_account',
     runtimeConfig,

package/src/openclaw/plugin/register.js

@@ -3,6 +3,8 @@ import {
   projectToolChatRequestListResponse,
   projectToolChatRequestMutationResponse,
   projectToolCreateWorldResponse,
+  projectToolManagedWorldResponse,
+  projectToolOwnedWorldsResponse,
   projectToolWorldList,
   projectToolFeedbackSubmissionResponse,
   projectToolJoinWorldResponse,
@@ -502,6 +504,120 @@ function buildRegisteredTools(api, plugin) {
         return buildToolResult(projectToolCreateWorldResponse(payload, { accountId: context.accountId }));
       },
     },
+    {
+      name: 'claworld_list_owned_worlds',
+      label: 'Claworld List Owned Worlds',
+      description: 'Owner-focused governance tool. List the worlds owned by the current account before choosing one to manage.',
+      metadata: buildToolMetadata({
+        category: 'world_management',
+        usageNotes: [
+          'Use when the user wants to inspect or pick from worlds they own.',
+          'This tool only returns owned worlds, not general directory worlds.',
+          'Pair this with claworld_manage_world for owner-only worldContext updates.',
+        ],
+        examples: [
+          {
+            title: 'List owned worlds',
+            input: {
+              accountId: 'claworld',
+            },
+            outcome: 'Returns owner-managed worlds for the current account.',
+          },
+        ],
+      }),
+      parameters: objectParam({
+        description: 'Minimal payload for listing worlds owned by the current account.',
+        required: ['accountId'],
+        properties: {
+          accountId: accountIdProperty,
+          includeDisabled: {
+            type: 'boolean',
+            description: 'Whether to include disabled or draft owned worlds.',
+          },
+        },
+        examples: [
+          {
+            accountId: 'claworld',
+          },
+        ],
+      }),
+      async execute(_toolCallId, params = {}) {
+        const context = await resolveToolContext(api, plugin, params);
+        const payload = await plugin.runtime.productShell.moderation.listOwnedWorlds({
+          ...context,
+          includeDisabled: params.includeDisabled !== false,
+        });
+        return buildToolResult(projectToolOwnedWorldsResponse(payload, { accountId: context.accountId }));
+      },
+    },
+    {
+      name: 'claworld_manage_world',
+      label: 'Claworld Manage World',
+      description: 'Owner-only world management tool. Update the canonical worldContextText for one owner-managed world, with optional displayName/enabled changes.',
+      metadata: buildToolMetadata({
+        category: 'world_management',
+        usageNotes: [
+          'Use only when the current agent owns the target world.',
+          'This is the minimal management tool on the current public surface.',
+          'Prefer updating worldContextText directly instead of editing legacy world schema fields.',
+        ],
+        examples: [
+          {
+            title: 'Update one owned world context',
+            input: {
+              accountId: 'claworld',
+              worldId: 'ugc-weekend-debate-club',
+              worldContextText: '世界：Weekend Debate Club [ugc-weekend-debate-club]\n简介：A creator-managed world for short structured debates.\n互动规则：Debate one topic at a time and stay concise.\n结果要求：Leave one clear 1 to 10 rating.',
+            },
+            outcome: 'Returns the updated managed-world projection when the current agent is the owner.',
+          },
+        ],
+      }),
+      parameters: objectParam({
+        description: 'Minimal owner-only world management payload.',
+        required: ['accountId', 'worldId', 'worldContextText'],
+        properties: {
+          accountId: accountIdProperty,
+          worldId: worldIdProperty,
+          worldContextText: stringParam({
+            description: 'Replacement canonical world context text for the owned world.',
+            minLength: 1,
+            examples: ['世界：Weekend Debate Club [ugc-weekend-debate-club]\n简介：A creator-managed world for short structured debates.\n互动规则：Debate one topic at a time and stay concise.\n结果要求：Leave one clear 1 to 10 rating.'],
+          }),
+          displayName: stringParam({
+            description: 'Optional new display name for the owned world.',
+            minLength: 1,
+            examples: ['Weekend Debate Club'],
+          }),
+          enabled: {
+            type: 'boolean',
+            description: 'Optional enabled flag for the owned world.',
+          },
+        },
+        examples: [
+          {
+            accountId: 'claworld',
+            worldId: 'ugc-weekend-debate-club',
+            worldContextText: '世界：Weekend Debate Club [ugc-weekend-debate-club]\n简介：A creator-managed world for short structured debates.\n互动规则：Debate one topic at a time and stay concise.\n结果要求：Leave one clear 1 to 10 rating.',
+          },
+        ],
+      }),
+      async execute(_toolCallId, params = {}) {
+        const context = await resolveToolContext(api, plugin, params);
+        const changes = {
+          worldContextText: params.worldContextText,
+          ...(params.displayName ? { displayName: params.displayName } : {}),
+        };
+        const payload = await plugin.runtime.productShell.moderation.manageWorld({
+          ...context,
+          worldId: params.worldId,
+          mode: 'patch',
+          changes,
+          ...(Object.prototype.hasOwnProperty.call(params, 'enabled') ? { enabled: params.enabled === true } : {}),
+        });
+        return buildToolResult(projectToolManagedWorldResponse(payload, { accountId: context.accountId }));
+      },
+    },
     {
       name: 'claworld_request_chat',
       label: 'Claworld Request Chat',

package/src/openclaw/runtime/tool-contracts.js

@@ -76,7 +76,7 @@ function projectParticipantContextField(field = null) {
 
 function projectWorldRole(worldRole, fallback = null) {
   const normalized = normalizeText(worldRole, fallback);
-  return ['owner', 'admin', 'member'].includes(normalized) ? normalized : fallback;
+  return ['owner', 'member'].includes(normalized) ? normalized : fallback;
 }
 
 function projectWorldStats(stats = null) {

package/src/openclaw/runtime/tool-inventory.js

@@ -22,6 +22,8 @@ export const CLAWORLD_WORLD_TOOL_NAMES = Object.freeze([
 
 export const CLAWORLD_WORLD_ADMIN_PUBLIC_TOOL_NAMES = Object.freeze([
   'claworld_create_world',
+  'claworld_list_owned_worlds',
+  'claworld_manage_world',
 ]);
 
 export const CLAWORLD_COMPATIBILITY_TOOL_NAMES = Object.freeze([
@@ -35,8 +37,6 @@ export const CLAWORLD_RETIRED_PUBLIC_TOOL_NAMES = Object.freeze([
   'claworld_accept_friend_request',
   'claworld_reject_friend_request',
   'claworld_broadcast_world',
-  'claworld_list_owned_worlds',
-  'claworld_manage_world',
   'claworld_resolve_agent',
 ]);
 

package/src/openclaw/runtime/world-moderation-helper.js

@@ -76,7 +76,7 @@ function normalizeWorldStats(stats = null) {
 
 function normalizeWorldRole(worldRole, fallback = null) {
   const normalized = normalizeText(worldRole, fallback);
-  return ['owner', 'admin', 'member'].includes(normalized) ? normalized : fallback;
+  return ['owner', 'member'].includes(normalized) ? normalized : fallback;
 }
 
 function normalizeManagedWorld(payload = {}) {

package/src/product-shell/catalog/default-world-catalog.js

@@ -2,283 +2,37 @@ export const DEFAULT_WORLD_MANIFESTS = Object.freeze([
   {
     worldId: 'dating-demo-world',
     displayName: 'Dating Demo World',
-    summary: 'Mutual-interest matching world for proving the A2A conversation loop before human handoff.',
+    summary: 'A lightweight social world for proving world-scoped join, review, and chat request flow.',
     description:
-      'A lightweight social world for people who want their agents to screen for mutual fit before deciding whether a human handoff is worthwhile.',
+      'A lightweight social world where agents compare fit briefly before deciding whether to continue beyond agent chat.',
     category: 'social',
     lifecycle: 'prototype',
     tags: ['dating', 'matching', 'a2a'],
-    interactionRules:
-      'Both agents should clarify fit quickly, stay respectful, avoid over-sharing, and stop once both sides can decide whether to continue beyond agent chat.',
-    prohibitedRules:
-      'Do not pressure, harass, manipulate, or ask for unsafe personal details. Do not continue pushing once the other side clearly signals discomfort or disinterest.',
-    ratingRules:
-      'When the interaction ends, each agent should rate the other side from 1 to 10 based on mutual fit, conversational quality, and respect for the world rules.',
-    roles: [
-      {
-        roleId: 'seeker',
-        label: 'Seeker',
-        objective: 'Find a compatible person and decide whether to raise hand.',
-        promptSummary: 'Represent your human owner faithfully and optimize for respectful fit.',
-      },
-      {
-        roleId: 'candidate',
-        label: 'Candidate',
-        objective: 'Assess alignment and decide whether to continue beyond agent-only chat.',
-        promptSummary: 'Share enough context to evaluate fit while staying concise and safe.',
-      },
-    ],
-    joinSchema: {
-      requiredFields: [
-        {
-          fieldId: 'headline',
-          label: 'Headline',
-          description: 'One-line self introduction shown during initial discovery.',
-          examples: ['Shanghai-based product lead who likes trail running'],
-        },
-        {
-          fieldId: 'intent',
-          label: 'Intent',
-          description: 'What kind of connection the user is open to.',
-          examples: ['serious relationship', 'new friends first'],
-        },
-        {
-          fieldId: 'location',
-          label: 'Location',
-          description: 'Current city or region used for basic filtering.',
-          examples: ['Shanghai'],
-        },
-      ],
-      optionalFields: [
-        {
-          fieldId: 'interests',
-          label: 'Interests',
-          type: 'string[]',
-          description: 'Interests or hobbies used for match prompts.',
-          examples: ['running', 'indie films', 'cats'],
-        },
-        {
-          fieldId: 'conversationStyle',
-          label: 'Conversation Style',
-          description: 'Tone preference for the agent during A2A chat.',
-          examples: ['playful but direct'],
-        },
-      ],
-      hints: [
-        'Keep profile fields concrete so both matching and prompt injection stay stable.',
-        'World-level rules should decide when two agents have effectively reached a human handoff threshold.',
-      ],
-    },
-    searchSchema: {
-      mode: 'profile_overlap_search',
-      inputFieldIds: ['intent', 'location', 'interests'],
-      summary:
-        'Compatibility-only manual search over active online members by intent, location, and shared interests. Candidate feed review is the canonical path before request_chat.',
-      hints: [
-        'Search defaults to the viewer membership profile when no explicit query is provided.',
-        'Only online members with an active world membership are returned.',
-      ],
-    },
-    matching: {
-      mode: 'scored_push',
-      cadence: 'periodic',
-      strategySummary:
-        'Score active online memberships by intent, location, and interests, deliver candidate summaries first, and route live contact through request_chat after review.',
-      candidateSources: ['active_memberships_online'],
-    },
-    conversationTemplate: {
-      mode: 'a2a',
-      worldRules: {
-        openingText: 'You are in the dating demo world. Clarify fit quickly and stop once both sides can decide whether to continue.',
-        turnMessageRules: [{ id: 'nudge-2', atTurn: 2, templateRef: 'world.turn.nudge' }],
-        convergence: {
-          whenRemainingTurnsLTE: 1,
-          text: 'Focus on unresolved blockers and whether both sides have enough information to decide next steps.',
-        },
-      },
-    },
-    resultContract: {
-      schemaId: 'dating-demo-world.result.v1',
-      outputs: ['match_score', 'recommendation', 'risks', 'evidence'],
-      successCriteria: ['both agents can summarize fit', 'next step is explicit'],
-      exampleSignals: {
-        intentSignals: [{ id: 'intent-1', type: 'intent_match', score: 0.8, summary: 'Stated intent aligns.' }],
-        conversationSignals: [
-          { id: 'conv-1', type: 'next_step_ready', score: 0.7, summary: 'One side is ready to stop and move forward.' },
-          { id: 'conv-2', type: 'next_step_ready', score: 0.7, summary: 'The other side is also ready to stop.' },
-        ],
-        agentSignals: [{ id: 'agent-1', type: 'safety', risk: 0.1, summary: 'No major risk surfaced.' }],
-      },
-    },
+    worldContextText:
+      '世界：Dating Demo World [dating-demo-world]\n简介：A lightweight social world for proving world-scoped join, review, and chat request flow.\n互动规则：Clarify fit quickly, stay respectful, and stop once next steps are clear.\n禁止事项：Do not pressure, harass, manipulate, or ask for unsafe personal details.\n结果要求：Rate the interaction from 1 to 10 based on fit, clarity, and respect.',
   },
   {
     worldId: 'skill-handoff-world',
     displayName: 'Skill Handoff World',
-    summary: 'Supply-demand world for small scoped skill requests before full project delivery and escrow are introduced.',
+    summary: 'A small scoped skill-handoff world for proving service-fit review before direct contact.',
     description:
-      'A service marketplace world where agents help their owners quickly screen for delivery fit before moving to a direct human conversation.',
+      'A service marketplace world where agents quickly screen delivery fit before moving to direct human contact.',
     category: 'marketplace',
     lifecycle: 'prototype',
     tags: ['skills', 'services', 'matching'],
-    interactionRules:
-      'Agents should clarify scope, constraints, expected deliverables, and whether a direct handoff is justified. Keep the exchange concrete and decision-oriented.',
-    prohibitedRules:
-      'Do not misrepresent capabilities, hide obvious delivery blockers, or pressure the other side into a commitment without clear scope alignment.',
-    ratingRules:
-      'At the end of the exchange, each agent should rate the other side from 1 to 10 based on scope clarity, responsiveness, and confidence in a productive handoff.',
-    roles: [
-      {
-        roleId: 'buyer',
-        label: 'Buyer',
-        objective: 'Describe a task crisply enough for rapid screening.',
-      },
-      {
-        roleId: 'seller',
-        label: 'Seller',
-        objective: 'Assess fit, delivery scope, and whether to continue to a human handoff.',
-      },
-    ],
-    joinSchema: {
-      requiredFields: [
-        {
-          fieldId: 'headline',
-          label: 'Headline',
-          description: 'What the user can buy or sell in one line.',
-        },
-        {
-          fieldId: 'capabilities',
-          label: 'Capabilities',
-          type: 'string[]',
-          description: 'Skills or request categories used during matching.',
-          examples: ['typescript', 'prompt design', 'landing page'],
-        },
-      ],
-      optionalFields: [
-        {
-          fieldId: 'budgetBand',
-          label: 'Budget Band',
-          description: 'Optional budget or rate band for screening.',
-          examples: ['200-500 USD', '50 USD/hour'],
-        },
-      ],
-      hints: ['Use this world to prove supply-demand matching before implementing transaction settlement.'],
-    },
-    searchSchema: {
-      mode: 'capability_overlap_search',
-      inputFieldIds: ['capabilities', 'budgetBand'],
-      summary:
-        'Compatibility-only manual search over active online members by capability overlap and optional budget fit. Candidate feed review is the canonical path before request_chat.',
-    },
-    matching: {
-      mode: 'intent_filter',
-      cadence: 'on_demand',
-      strategySummary:
-        'Filter active online world members by capability overlap, deliver candidate summaries first, and let members request_chat before negotiating fit in a short session.',
-      candidateSources: ['active_memberships_online'],
-    },
-    conversationTemplate: {
-      mode: 'a2a',
-      worldRules: {
-        openingText: 'Clarify scope, constraints, and whether a human handoff is justified.',
-      },
-    },
-    resultContract: {
-      schemaId: 'skill-handoff-world.result.v1',
-      outputs: ['recommendation', 'risks', 'evidence'],
-      successCriteria: ['scope is summarized', 'handoff recommendation is explicit'],
-      exampleSignals: {
-        intentSignals: [{ id: 'intent-1', type: 'intent_match', score: 0.65, summary: 'Capabilities appear relevant.' }],
-        conversationSignals: [{ id: 'conv-1', type: 'human_handoff_ready', score: 0.6, summary: 'Seller is ready for human handoff.' }],
-        agentSignals: [{ id: 'agent-1', type: 'scope_risk', risk: 0.2, summary: 'A few requirements remain vague.' }],
-      },
-    },
+    worldContextText:
+      '世界：Skill Handoff World [skill-handoff-world]\n简介：A service marketplace world where agents screen delivery fit before moving to direct human contact.\n互动规则：Clarify scope, constraints, and whether a handoff is justified.\n禁止事项：Do not misrepresent capabilities or hide delivery blockers.\n结果要求：Rate the exchange from 1 to 10 based on scope clarity and handoff confidence.',
   },
   {
     worldId: 'job-match-world',
     displayName: 'Job Match World',
-    summary: 'Recruiter-candidate world optimized for profile completeness, matching, and concise A2A screening.',
+    summary: 'A hiring-fit world optimized for profile completeness, matching, and concise A2A screening.',
     description:
-      'A recruiting world for agent-assisted screening where candidates and recruiters validate fit before escalating to direct human contact.',
+      'A recruiting world for agent-assisted screening where both sides validate fit before escalating to direct human contact.',
     category: 'recruiting',
     lifecycle: 'prototype',
     tags: ['jobs', 'recruiting', 'screening'],
-    interactionRules:
-      'Agents should focus on role fit, experience relevance, hiring constraints, and whether a direct next step is justified. Keep the conversation concise and factual.',
-    prohibitedRules:
-      'Do not fabricate experience, compensation expectations, or hiring authority. Do not request sensitive personal data unrelated to the role fit conversation.',
-    ratingRules:
-      'When the interaction ends, each agent should rate the other side from 1 to 10 based on role fit, signal quality, and likelihood that a human follow-up is worthwhile.',
-    roles: [
-      {
-        roleId: 'candidate',
-        label: 'Candidate',
-        objective: 'Surface fit and blockers quickly.',
-      },
-      {
-        roleId: 'recruiter',
-        label: 'Recruiter',
-        objective: 'Determine whether to escalate to human contact.',
-      },
-    ],
-    joinSchema: {
-      requiredFields: [
-        {
-          fieldId: 'headline',
-          label: 'Headline',
-          description: 'Current role or target role.',
-        },
-        {
-          fieldId: 'experienceSummary',
-          label: 'Experience Summary',
-          description: 'Condensed summary of experience relevant to matching.',
-        },
-        {
-          fieldId: 'targetRole',
-          label: 'Target Role',
-          description: 'Role or hiring need that anchors matching.',
-        },
-      ],
-      optionalFields: [
-        {
-          fieldId: 'location',
-          label: 'Location',
-        },
-        {
-          fieldId: 'workMode',
-          label: 'Work Mode',
-          description: 'Onsite, hybrid, or remote.',
-        },
-      ],
-      hints: ['This world should eventually integrate search/browse, but the current shell only defines the contract.'],
-    },
-    searchSchema: {
-      mode: 'profile_overlap_search',
-      inputFieldIds: ['targetRole', 'location', 'workMode'],
-      summary:
-        'Compatibility-only manual search over active online members by role fit, location, and work mode. Candidate feed review is the canonical path before request_chat.',
-    },
-    matching: {
-      mode: 'profile_overlap',
-      cadence: 'periodic',
-      strategySummary:
-        'Use active online memberships plus target role, experience summary, and location/work mode as the first-pass scoring surface, deliver candidate summaries, and route contact through request_chat after review.',
-      candidateSources: ['active_memberships_online'],
-    },
-    conversationTemplate: {
-      mode: 'a2a',
-      worldRules: {
-        openingText: 'Focus on role fit, constraints, and whether both sides should move to a human conversation.',
-      },
-    },
-    resultContract: {
-      schemaId: 'job-match-world.result.v1',
-      outputs: ['match_score', 'recommendation', 'risks', 'evidence'],
-      successCriteria: ['role fit is explicit', 'human next step is explicit'],
-      exampleSignals: {
-        intentSignals: [{ id: 'intent-1', type: 'role_fit', score: 0.7, summary: 'Role expectations line up.' }],
-        conversationSignals: [{ id: 'conv-1', type: 'next_step_ready', score: 0.55, summary: 'Both sides are ready to stop and proceed.' }],
-        agentSignals: [{ id: 'agent-1', type: 'timeline_risk', risk: 0.15, summary: 'Availability still needs confirmation.' }],
-      },
-    },
+    worldContextText:
+      '世界：Job Match World [job-match-world]\n简介：A recruiting world for agent-assisted screening before direct human contact.\n互动规则：Focus on fit, constraints, and whether a next step is justified.\n禁止事项：Do not fabricate experience, compensation, or hiring authority.\n结果要求：Rate the interaction from 1 to 10 based on fit, clarity, and follow-up likelihood.',
   },
 ]);

package/src/product-shell/contracts/world-manifest.js

@@ -77,16 +77,6 @@ function normalizeField(field = {}, index = 0, { required = false } = {}) {
   };
 }
 
-function normalizeRole(role = {}, index = 0) {
-  const roleId = normalizeText(role.roleId || role.id, `role_${index + 1}`);
-  return {
-    roleId,
-    label: normalizeText(role.label, roleId),
-    objective: normalizeText(role.objective, null),
-    promptSummary: normalizeText(role.promptSummary, null),
-  };
-}
-
 function normalizeExampleSignals(exampleSignals = {}) {
   const normalizeGroup = (key) => (Array.isArray(exampleSignals[key]) ? exampleSignals[key] : []);
   return {
@@ -207,7 +197,6 @@ export function normalizeWorldManifest(manifest = {}, index = 0) {
       ratingRules: normalizedRatingRules,
     }),
     creatorAgentId: normalizeText(manifest.creatorAgentId, null),
-    adminAgentIds: normalizeStringList(manifest.adminAgentIds),
     eligibility: normalizeWorldEligibility(manifest.eligibility, 'active'),
     broadcast: normalizeBroadcastConfig(manifest.broadcast, {
       enabled: manifest.broadcast?.enabled === true,
@@ -224,9 +213,6 @@ export function normalizeWorldManifest(manifest = {}, index = 0) {
           : 0,
       }
       : { totalConversationCount: 0 },
-    roles: Array.isArray(manifest.roles)
-      ? manifest.roles.map((role, roleIndex) => normalizeRole(role, roleIndex))
-      : [],
     joinSchema,
     searchSchema,
     matching: {

package/src/product-shell/contracts/world-orchestration.js

@@ -174,7 +174,6 @@ function normalizeWorldDetail(payload = {}) {
       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,
@@ -237,7 +236,6 @@ function normalizeWorldDetail(payload = {}) {
     interactionRules: normalizeText(payload.interactionRules || world.interactionRules, null),
     prohibitedRules: normalizeText(payload.prohibitedRules || world.prohibitedRules, null),
     ratingRules: normalizeText(payload.ratingRules || world.ratingRules, null),
-    adminAgentIds: normalizeStringList(payload.adminAgentIds || world.adminAgentIds),
     eligibility: normalizeText(payload.eligibility || world.eligibility, 'active'),
     broadcast: normalizeBroadcastConfig(payload.broadcast || world.broadcast),
     requiredFields,

package/src/product-shell/index.js

@@ -132,6 +132,7 @@ export function createClaworldProductShell({
           'GET /v1/chat-requests',
           'PUT /v1/chat-requests/approval-policy',
           'POST /v1/chat-requests/:chatRequestId/accept',
+          'POST /v1/chat-requests/:chatRequestId/reject',
           'GET /v1/worlds',
           'GET /v1/worlds/:worldId',
           'POST /v1/worlds',

package/src/product-shell/membership/membership-service.js

@@ -81,9 +81,13 @@ export function createMembershipService({ worldService, store = null } = {}) {
   }
 
   return {
-    evaluateJoin({ worldId, participantContextText = null } = {}) {
+    evaluateJoin({ worldId, participantContextText = null, profile = null, profileSnapshot = null } = {}) {
       const world = worldService.requireWorld(worldId);
-      const normalizedParticipantContextText = normalizeText(participantContextText, null);
+      const normalizedParticipantContextText = resolveNormalizedParticipantContextText({
+        world,
+        participantContextText,
+        profileSnapshot: profileSnapshot || profile,
+      });
       const accepted = Boolean(normalizedParticipantContextText);
 
       return {
@@ -132,7 +136,7 @@ export function createMembershipService({ worldService, store = null } = {}) {
       };
     },
 
-    async createMembership({ worldId, agentId, participantContextText } = {}) {
+    async createMembership({ worldId, agentId, participantContextText, profile = null, profileSnapshot = null } = {}) {
       const world = worldService.requireWorld(worldId);
       const membershipStore = assertStore();
       const normalizedAgentId = normalizeAgentId(agentId);
@@ -145,6 +149,7 @@ export function createMembershipService({ worldService, store = null } = {}) {
         world,
         agent,
         participantContextText,
+        profileSnapshot: profileSnapshot || profile,
       });
       if (!normalizedParticipantContextText) {
         throw createInvalidJoinRequestError(
@@ -166,7 +171,7 @@ export function createMembershipService({ worldService, store = null } = {}) {
         worldId,
         agentId: normalizedAgentId,
         status: 'joined',
-        profileSnapshot: normalizeProfileSnapshot(null, normalizedParticipantContextText),
+        profileSnapshot: normalizeProfileSnapshot(profileSnapshot || profile, normalizedParticipantContextText),
         participantContextText: normalizedParticipantContextText,
       });
 
@@ -177,6 +182,8 @@ export function createMembershipService({ worldService, store = null } = {}) {
       worldId,
       agentId,
       participantContextText,
+      profile = null,
+      profileSnapshot = null,
     } = {}) {
       const world = worldService.requireWorld(worldId);
       const membershipStore = assertStore();
@@ -191,6 +198,7 @@ export function createMembershipService({ worldService, store = null } = {}) {
         world,
         agent,
         participantContextText,
+        profileSnapshot: profileSnapshot || profile,
       });
       if (!normalizedParticipantContextText) {
         throw createInvalidJoinRequestError(
@@ -207,14 +215,24 @@ export function createMembershipService({ worldService, store = null } = {}) {
       const membership = existingMembership
         ? await membershipStore.updateMembership(existingMembership.membershipId, {
           status: 'active',
-          profileSnapshot: normalizeProfileSnapshot(existingMembership.profileSnapshot, normalizedParticipantContextText),
+          profileSnapshot: normalizeProfileSnapshot(
+            {
+              ...(existingMembership.profileSnapshot && typeof existingMembership.profileSnapshot === 'object'
+                ? existingMembership.profileSnapshot
+                : {}),
+              ...((profileSnapshot || profile) && typeof (profileSnapshot || profile) === 'object' && !Array.isArray(profileSnapshot || profile)
+                ? (profileSnapshot || profile)
+                : {}),
+            },
+            normalizedParticipantContextText,
+          ),
           participantContextText: normalizedParticipantContextText,
         })
         : await membershipStore.createMembership({
           worldId: world.worldId,
           agentId: normalizedAgentId,
           status: 'active',
-          profileSnapshot: normalizeProfileSnapshot(null, normalizedParticipantContextText),
+          profileSnapshot: normalizeProfileSnapshot(profileSnapshot || profile, normalizedParticipantContextText),
           participantContextText: normalizedParticipantContextText,
         });
 

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

@@ -104,4 +104,24 @@ export function registerChatRequestRoutes(app, { chatRequestService, store }) {
       sendChatRequestError(res, error);
     }
   });
+
+  app.post('/v1/chat-requests/:chatRequestId/reject', async (req, res) => {
+    const authAgent = resolveAuthenticatedAgentId({
+      store,
+      req,
+      providedAgentId: req.body?.actorAgentId,
+      fieldName: 'actorAgentId',
+    });
+    if (!authAgent.ok) return res.status(authAgent.status).json(authAgent.body);
+    if (!authAgent.agentId) return sendMissingAgentIdentity(res);
+
+    try {
+      const result = await chatRequestService.rejectChatRequest(req.params.chatRequestId, {
+        actorAgentId: authAgent.agentId,
+      });
+      res.json(result);
+    } catch (error) {
+      sendChatRequestError(res, error);
+    }
+  });
 }

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

@@ -534,5 +534,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() {
@@ -193,42 +162,36 @@ function buildWorldRecord({
   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,
+    ratingRules: 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,
+    ratingRules: null,
+    worldContextText: resolvedWorldContextText,
     joinSchema: {
       requiredFields: [participantContextField],
       optionalFields: [],
@@ -236,16 +199,13 @@ function buildWorldRecord({
     },
     searchSchema: buildSearchSchema(),
     matching: buildMatchingStrategy(),
-    conversationTemplate: buildConversationTemplate(interactionRules, prohibitedRules, {
-      existingConversationTemplate,
-    }),
-    resultContract: buildResultContract(worldId, ratingRules),
+    conversationTemplate: buildConversationTemplate(null, null),
+    resultContract: buildResultContract(worldId, null),
     meta: {
       status: resolvedStatus === 'enabled' ? 'creator_enabled' : 'creator_draft',
       persistence: 'store',
     },
     creatorAgentId,
-    adminAgentIds: [],
     eligibility: 'active',
     broadcast: {
       enabled: false,
@@ -255,7 +215,7 @@ function buildWorldRecord({
     },
     status: resolvedStatus,
     enabled,
-    schemaVersion,
+    schemaVersion: 1,
     metrics: existingMetrics || {
       totalConversationCount: 0,
     },
@@ -339,29 +299,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,
       });
@@ -413,8 +362,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 +379,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 +392,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 +404,6 @@ export function createWorldAdminService({ worldService, worldAuthorizationServic
         });
       }
 
-      let nextSchemaVersion = Number(existingWorld.schemaVersion || 1);
       let nextRecord = existingWorld;
 
       if (hasChanges) {
@@ -479,18 +416,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 +436,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,10 @@ 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 resolveActionRequirement(action) {
@@ -37,11 +35,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 +70,18 @@ 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 });
 
     return {
       world,
       actorAgentId: normalizedActorAgentId,
       worldRole,
-      managementRole: isOwner ? WORLD_ROLES.OWNER : isAdmin ? WORLD_ROLES.ADMIN : null,
+      managementRole: isOwner ? WORLD_ROLES.OWNER : null,
       membership,
       membershipStatus: membership?.status || null,
       roles: {
         owner: isOwner,
-        admin: isAdmin,
         member: isMember,
       },
     };
@@ -125,7 +114,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);
     },

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

@@ -86,7 +86,7 @@ function createBroadcastNotAllowedError({ worldId, senderAgentId, senderRole } =
     worldId,
     senderAgentId,
     senderRole,
-    allowedRoles: ['owner', 'admin'],
+    allowedRoles: ['owner'],
   };
   return error;
 }
@@ -138,10 +138,7 @@ export function createWorldBroadcastService({
 
   function resolveAudienceAgentIds(world, { audience, excludeSelf, senderAgentId } = {}) {
     if (audience === 'admins' || audience === 'admins_and_owner') {
-      return dedupeAgentIds([
-        world.creatorAgentId,
-        ...(Array.isArray(world.adminAgentIds) ? world.adminAgentIds : []),
-      ], {
+      return dedupeAgentIds([world.creatorAgentId], {
         excludeAgentId: excludeSelf ? senderAgentId : null,
       });
     }