@xfxstudio/claworld 0.2.5 → 0.2.7

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.',
   },
   {
     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.',
   },
   {
     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.',
   },
 ]);

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

@@ -77,25 +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 {
-    intentSignals: normalizeGroup('intentSignals'),
-    conversationSignals: normalizeGroup('conversationSignals'),
-    agentSignals: normalizeGroup('agentSignals'),
-  };
-}
-
 function normalizeJoinSchema(joinSchema = {}) {
   return {
     requiredFields: [
@@ -177,10 +158,6 @@ export function normalizeWorldManifest(manifest = {}, index = 0) {
   const defaultInteractionRules = normalizeText(conversationTemplate?.worldRules?.openingText, null);
   const normalizedInteractionRules = normalizeText(manifest.interactionRules, defaultInteractionRules);
   const normalizedProhibitedRules = normalizeText(manifest.prohibitedRules, null);
-  const normalizedRatingRules = normalizeText(
-    manifest.ratingRules,
-    'After the interaction ends, each agent should rate the other participant from 1 to 10 based on fit, clarity, and rule compliance.',
-  );
 
   return {
     worldId,
@@ -193,7 +170,6 @@ export function normalizeWorldManifest(manifest = {}, index = 0) {
     tags: normalizeStringList(manifest.tags),
     interactionRules: normalizedInteractionRules,
     prohibitedRules: normalizedProhibitedRules,
-    ratingRules: normalizedRatingRules,
     worldContextText: buildWorldContextText({
       worldId,
       displayName: normalizeText(manifest.displayName, worldId),
@@ -204,10 +180,8 @@ export function normalizeWorldManifest(manifest = {}, index = 0) {
       ),
       interactionRules: normalizedInteractionRules,
       prohibitedRules: normalizedProhibitedRules,
-      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 +198,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: {
@@ -246,12 +217,6 @@ export function normalizeWorldManifest(manifest = {}, index = 0) {
         stateChangeMessages: conversationTemplate?.worldRules?.stateChangeMessages || {},
       },
     },
-    resultContract: {
-      schemaId: normalizeText(manifest.resultContract?.schemaId, `${worldId}.result.v1`),
-      outputs: normalizeStringList(manifest.resultContract?.outputs),
-      successCriteria: normalizeStringList(manifest.resultContract?.successCriteria),
-      exampleSignals: normalizeExampleSignals(manifest.resultContract?.exampleSignals),
-    },
     meta: {
       status: normalizeText(manifest.meta?.status, 'scaffold_ready'),
       persistence: normalizeText(manifest.meta?.persistence, 'in_memory_catalog'),
@@ -325,7 +290,6 @@ export function projectWorldDetail(world) {
       summary: world.summary,
       interactionRules: world.interactionRules,
       prohibitedRules: world.prohibitedRules,
-      ratingRules: world.ratingRules,
       conversationMode: world.conversationTemplate.mode,
       conversationOverview: {
         worldId: world.worldId,
@@ -373,7 +337,6 @@ export function projectConversationWorldContext(world) {
         summary: world.summary,
         interactionRules: world.interactionRules,
         prohibitedRules: world.prohibitedRules,
-        ratingRules: world.ratingRules,
         conversationMode: world.conversationTemplate.mode,
         conversationOverview: {
           worldId: world.worldId,
@@ -392,7 +355,6 @@ export function projectConversationWorldContext(world) {
     worldContextText: runtimeWorldContext.text,
     interactionRules: world.interactionRules,
     prohibitedRules: world.prohibitedRules,
-    ratingRules: world.ratingRules,
     conversationMode: world.conversationTemplate.mode,
     conversationOverview: {
       worldId: world.worldId,

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

@@ -173,8 +173,6 @@ function normalizeWorldDetail(payload = {}) {
       conversationMode: normalizeText(payload.conversationMode, 'a2a'),
       interactionRules: normalizeText(payload.interactionRules, null),
       prohibitedRules: normalizeText(payload.prohibitedRules, null),
-      ratingRules: normalizeText(payload.ratingRules, null),
-      adminAgentIds: normalizeStringList(payload.adminAgentIds),
       eligibility: normalizeText(payload.eligibility, 'active'),
       broadcast: normalizeBroadcastConfig(payload.broadcast),
       requiredFields,
@@ -236,8 +234,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,
@@ -424,7 +420,6 @@ export function buildWorldSessionStartupText(detail = {}) {
   const convergenceText = normalizeText(conversationOverview.convergence?.text, null);
   const interactionRules = normalizeText(normalizedDetail.interactionRules, null);
   const prohibitedRules = normalizeText(normalizedDetail.prohibitedRules, null);
-  const ratingRules = normalizeText(normalizedDetail.ratingRules, null);
 
   const lines = [
     'Internal Claworld world context for this conversation.',
@@ -436,7 +431,6 @@ export function buildWorldSessionStartupText(detail = {}) {
     openingText ? `Opening focus: ${openingText}` : null,
     interactionRules ? `Interaction rules: ${interactionRules}` : null,
     prohibitedRules ? `Prohibited rules: ${prohibitedRules}` : null,
-    ratingRules ? `Rating rules: ${ratingRules}` : null,
     convergenceText ? `Convergence rule: ${convergenceText}` : null,
     'Apply these world rules symmetrically when responding in this conversation.',
   ].filter(Boolean);

package/src/product-shell/index.js

@@ -9,7 +9,6 @@ import { registerOnboardingRoutes } from './onboarding/onboarding-routes.js';
 import { createMembershipService } from './membership/membership-service.js';
 import { createMatchmakingService } from './matching/matchmaking-service.js';
 import { createWorldSearchService } from './search/search-service.js';
-import { createResultService } from './results/result-service.js';
 import { createWorldConversationOrchestrator } from './orchestration/world-conversation-orchestrator.js';
 import { createSocialService } from './social/social-service.js';
 import { registerSocialRoutes } from './social/social-routes.js';
@@ -50,7 +49,6 @@ export function createClaworldProductShell({
     chatRequestService,
     store,
   });
-  const resultService = createResultService();
   const friendService = createFriendService({ store, policy: relay?.policy });
   const socialLookupService = createSocialService({ worldService, store });
   const feedbackService = createFeedbackService({ store });
@@ -62,7 +60,6 @@ export function createClaworldProductShell({
   };
   const worldConversationOrchestrator = createWorldConversationOrchestrator({
     worldService,
-    resultService,
   });
 
   const productShell = {
@@ -78,7 +75,6 @@ export function createClaworldProductShell({
       chatRequests: chatRequestService,
       moderation: worldAdminService,
       feedback: feedbackService,
-      results: resultService,
       orchestration: worldConversationOrchestrator,
     },
     registerRoutes(app) {
@@ -115,7 +111,6 @@ export function createClaworldProductShell({
           'moderation',
           'feedback',
           'orchestration',
-          'results',
         ],
         routes: [
           'GET /v1/meta/product-shell',
@@ -132,6 +127,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/orchestration/world-conversation-orchestrator.js

@@ -2,7 +2,6 @@ import { createSystemMessageOrchestrator } from './world-conversation-text.js';
 
 export function createWorldConversationOrchestrator({
   worldService,
-  resultService,
   systemMessages = createSystemMessageOrchestrator(),
 } = {}) {
   return {
@@ -22,7 +21,6 @@ export function createWorldConversationOrchestrator({
         },
         openingPlan,
         convergencePlan,
-        resultPreview: resultService.previewConversation({ world, conversationKey }),
         status: 'preview_ready',
       };
     },

package/src/product-shell/orchestration/world-conversation-text.js

@@ -86,7 +86,6 @@ export function buildWorldConversationContextEvent(detail = {}) {
   const convergenceText = normalizeText(conversationOverview.convergence?.text, null);
   const interactionRules = normalizeText(detail.interactionRules, null);
   const prohibitedRules = normalizeText(detail.prohibitedRules, null);
-  const ratingRules = normalizeText(detail.ratingRules, null);
 
   const lines = [
     'Internal Claworld world context for this conversation.',
@@ -98,7 +97,6 @@ export function buildWorldConversationContextEvent(detail = {}) {
     openingText ? `Opening focus: ${openingText}` : null,
     interactionRules ? `Interaction rules: ${interactionRules}` : null,
     prohibitedRules ? `Prohibited rules: ${prohibitedRules}` : null,
-    ratingRules ? `Rating rules: ${ratingRules}` : null,
     convergenceText ? `Convergence rule: ${convergenceText}` : null,
     'Apply these world rules symmetrically when responding in this conversation.',
   ].filter(Boolean);

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

@@ -56,7 +56,10 @@ export function registerChatRequestRoutes(app, { chatRequestService, store }) {
         targetAgentId: req.body?.targetAgentId,
         kickoffBrief: req.body?.kickoffBrief,
         openingMessage: req.body?.openingMessage,
+        openingPayload: req.body?.openingPayload,
         worldId: req.body?.worldId,
+        requestContext: req.body?.requestContext,
+        source: req.body?.source,
       });
       res.status(201).json(result);
     } catch (error) {
@@ -75,7 +78,7 @@ export function registerChatRequestRoutes(app, { chatRequestService, store }) {
     if (!authAgent.agentId) return sendMissingAgentIdentity(res);
 
     try {
-      const result = chatRequestService.listChatRequests({
+      const result = chatRequestService.listChatInbox({
         agentId: authAgent.agentId,
         direction: req.query.direction,
       });
@@ -104,4 +107,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);
+    }
+  });
 }