@xfxstudio/claworld 0.1.4 → 0.2.0

package/src/product-shell/contracts/candidate-feed.js

@@ -7,6 +7,7 @@ export const CANDIDATE_OBJECT_FIELDS = Object.freeze([
   'worldId',
   'targetAgentId',
   'sourceMembershipId',
+  'online',
   'requestChat',
   'profileSummary',
   'compatibilitySignals',
@@ -100,6 +101,16 @@ function normalizeComparableText(value) {
   return normalizeText(value, null)?.toLowerCase() || null;
 }
 
+function tokenizeText(value) {
+  return [...new Set(
+    String(value || '')
+      .toLowerCase()
+      .split(/[^a-z0-9\u4e00-\u9fff]+/i)
+      .map((entry) => entry.trim())
+      .filter((entry) => entry.length >= 2),
+  )];
+}
+
 function projectSummaryField(field = {}, profile = {}) {
   const normalizedValue = normalizeValue(profile[field.fieldId], field);
   if (normalizedValue == null) return null;
@@ -115,7 +126,7 @@ function projectSummaryField(field = {}, profile = {}) {
 function projectProfileSummary(world, profile = {}, agent = null) {
   return {
     displayName: normalizeText(agent?.displayName, null),
-    headline: normalizeText(profile.headline, null),
+    headline: normalizeText(profile.participantContextText, normalizeText(profile.headline, null)),
     requiredFields: world.joinSchema.requiredFields
       .map((field) => projectSummaryField(field, profile))
       .filter(Boolean),
@@ -136,6 +147,21 @@ function createCompatibilitySignal({ sourceMembershipId, type, fieldIds, score,
 }
 
 function compareFieldValues(field, viewerValue, candidateValue, sourceMembershipId) {
+  if (field.fieldId === 'participantContextText') {
+    const viewerTokens = tokenizeText(viewerValue);
+    const candidateTokens = tokenizeText(candidateValue);
+    const sharedItems = viewerTokens.filter((item) => candidateTokens.includes(item));
+    if (sharedItems.length === 0) return null;
+
+    return createCompatibilitySignal({
+      sourceMembershipId,
+      type: 'field_overlap',
+      fieldIds: [field.fieldId],
+      score: Math.min(sharedItems.length * 0.08, 0.48),
+      summary: `Shared context: ${sharedItems.slice(0, 6).join(', ')}.`,
+    });
+  }
+
   if (field.type === 'string[]') {
     const viewerItems = normalizeComparableArray(viewerValue);
     const candidateItems = normalizeComparableArray(candidateValue);
@@ -180,7 +206,7 @@ function buildCompatibilitySignals(world, viewerProfile = {}, candidateProfile =
       type: 'world_ready',
       fieldIds: [],
       score: 0.05,
-      summary: 'Candidate has an active world membership and is ready for agent review before live session handoff.',
+      summary: 'Candidate is online with an active world membership and is ready for agent review before live session handoff.',
     }),
   ];
 }
@@ -192,7 +218,7 @@ function buildDeliveryReason(signals = []) {
     return {
       code: 'world_membership_ready',
       matchedFieldIds: [],
-      summary: 'Delivered for manual review because the candidate is active in this world, even though no direct profile overlap signal was detected yet.',
+      summary: 'Delivered for manual review because the candidate is online and active in this world, even though no direct profile overlap signal was detected yet.',
     };
   }
 
@@ -264,7 +290,7 @@ export function projectCandidateFeedModel(world) {
     },
     liveDeliveryEvent: projectLiveDeliveryEvent(world, candidateFields),
     summary:
-      'Active members can review candidate opportunities first, then call request_chat with the selected targetAgentId when they want to start a world-scoped conversation request.',
+      'Active online members can review candidate opportunities first, then call request_chat with the selected targetAgentId when they want to start a world-scoped conversation request.',
     status: 'phase1_candidate_feed',
   };
 }
@@ -274,6 +300,7 @@ function projectCandidateOpportunity({
   viewerProfile,
   candidateMembership,
   candidateAgent,
+  candidatePresence,
   expiresAt,
 }) {
   const profileSnapshot = candidateMembership.profileSnapshot || {};
@@ -290,6 +317,7 @@ function projectCandidateOpportunity({
     worldId: world.worldId,
     sourceMembershipId: candidateMembership.membershipId,
     targetAgentId: requestChat?.targetAgentId || null,
+    online: candidatePresence?.online === true,
     requestChat,
     profileSummary: projectProfileSummary(world, profileSnapshot, candidateAgent),
     compatibilitySignals,
@@ -304,6 +332,7 @@ export function buildCandidateFeed({
   viewerAgent = null,
   candidateMemberships = [],
   getAgent = () => null,
+  getPresence = () => ({ online: true }),
   nowMs = Date.now(),
   limit = DEFAULT_CANDIDATE_FEED_LIMIT,
 }) {
@@ -315,12 +344,18 @@ export function buildCandidateFeed({
 
   const candidates = candidateMemberships
     .filter((membership) => membership?.status === 'active' && membership.membershipId !== viewerMembership.membershipId)
-    .map((membership) => {
+    .map((membership) => ({
+      membership,
+      candidatePresence: getPresence(membership.agentId),
+    }))
+    .filter(({ candidatePresence }) => candidatePresence?.online === true)
+    .map(({ membership, candidatePresence }) => {
       const opportunity = projectCandidateOpportunity({
         world,
         viewerProfile,
         candidateMembership: membership,
         candidateAgent: getAgent(membership.agentId),
+        candidatePresence,
         expiresAt,
       });
 

package/src/product-shell/contracts/chat-request-approval-policy.js

@@ -1,4 +1,4 @@
-const DEFAULT_MODE = 'manual_review';
+const DEFAULT_MODE = 'open';
 const SUPPORTED_MODES = Object.freeze([
   DEFAULT_MODE,
   'world_only',
@@ -45,7 +45,7 @@ export function normalizeChatRequestApprovalMode(value, fallback = DEFAULT_MODE)
     case 'manual':
     case 'manual_review':
     case 'review':
-      return DEFAULT_MODE;
+      return 'manual_review';
     case 'world':
     case 'world_only':
       return 'world_only';
@@ -88,7 +88,7 @@ export function normalizeChatRequestApprovalPolicy(
     : normalizedLegacyAutoAccept === true
       ? 'open'
       : normalizedLegacyAutoAccept === false
-        ? DEFAULT_MODE
+        ? 'manual_review'
         : normalizeChatRequestApprovalMode(fallbackMode, DEFAULT_MODE);
 
   return {

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

@@ -1,5 +1,6 @@
 import { projectCandidateFeedModel } from './candidate-feed.js';
 import { buildWorldSessionStartupText } from './world-orchestration.js';
+import { buildWorldContextText } from '../worlds/world-text.js';
 
 function normalizeText(value, fallback = null) {
   if (value == null) return fallback;
@@ -12,6 +13,24 @@ function normalizeStringList(values = []) {
   return [...new Set(values.map((value) => normalizeText(value, null)).filter(Boolean))];
 }
 
+function normalizeCandidateSource(value) {
+  const normalized = normalizeText(value, null);
+  if (!normalized) return null;
+  if (
+    normalized === 'active_memberships'
+    || normalized === 'world_members'
+    || normalized === 'search_results'
+  ) {
+    return 'active_memberships_online';
+  }
+  return normalized;
+}
+
+function normalizeCandidateSources(values = []) {
+  if (!Array.isArray(values)) return [];
+  return [...new Set(values.map((value) => normalizeCandidateSource(value)).filter(Boolean))];
+}
+
 function normalizeWorldEligibility(value, fallback = 'active') {
   const normalized = normalizeText(value, fallback);
   if (normalized === 'joined') return 'joined';
@@ -78,17 +97,21 @@ function normalizeExampleSignals(exampleSignals = {}) {
 }
 
 function normalizeJoinSchema(joinSchema = {}) {
-  const requiredFields = Array.isArray(joinSchema.requiredFields)
-    ? joinSchema.requiredFields.map((field, index) => normalizeField(field, index, { required: true }))
-    : [];
-  const optionalFields = Array.isArray(joinSchema.optionalFields)
-    ? joinSchema.optionalFields.map((field, index) => normalizeField(field, index, { required: false }))
-    : [];
-
   return {
-    requiredFields,
-    optionalFields,
-    hints: normalizeStringList(joinSchema.hints),
+    requiredFields: [
+      {
+        fieldId: 'participantContextText',
+        label: 'Entry Profile',
+        type: 'string',
+        source: 'membership',
+        required: true,
+        description: 'Free-form participant profile/context text used for world join, search, and candidate review.',
+        examples: [],
+        constraints: {},
+      },
+    ],
+    optionalFields: [],
+    hints: [],
   };
 }
 
@@ -139,12 +162,25 @@ function normalizeSearchSchema(searchSchema = {}, joinSchema = {}) {
   };
 }
 
+function resolveConversationTemplateInput(manifest = {}) {
+  if (manifest.conversationTemplate && typeof manifest.conversationTemplate === 'object' && !Array.isArray(manifest.conversationTemplate)) {
+    return manifest.conversationTemplate;
+  }
+  return {};
+}
+
 export function normalizeWorldManifest(manifest = {}, index = 0) {
   const worldId = normalizeText(manifest.worldId || manifest.id, `world_${index + 1}`);
   const joinSchema = normalizeJoinSchema(manifest.joinSchema);
   const searchSchema = normalizeSearchSchema(manifest.searchSchema, joinSchema);
-  const defaultInteractionRules = normalizeText(manifest.sessionTemplate?.worldRules?.openingText, null);
-  const defaultProhibitedRules = normalizeText(manifest.sessionTemplate?.raiseHandPolicy?.summary, null);
+  const conversationTemplate = resolveConversationTemplateInput(manifest);
+  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,
@@ -155,12 +191,21 @@ export function normalizeWorldManifest(manifest = {}, index = 0) {
     category: normalizeText(manifest.category, 'general'),
     lifecycle: normalizeText(manifest.lifecycle, 'scaffold'),
     tags: normalizeStringList(manifest.tags),
-    interactionRules: normalizeText(manifest.interactionRules, defaultInteractionRules),
-    prohibitedRules: normalizeText(manifest.prohibitedRules, defaultProhibitedRules),
-    ratingRules: 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.',
-    ),
+    interactionRules: normalizedInteractionRules,
+    prohibitedRules: normalizedProhibitedRules,
+    ratingRules: normalizedRatingRules,
+    worldContextText: buildWorldContextText({
+      worldId,
+      displayName: normalizeText(manifest.displayName, worldId),
+      summary: normalizeText(manifest.summary, null),
+      worldContextText: normalizeText(
+        manifest.worldContextText,
+        normalizeText(manifest.runtimeWorldContext?.text, null),
+      ),
+      interactionRules: normalizedInteractionRules,
+      prohibitedRules: normalizedProhibitedRules,
+      ratingRules: normalizedRatingRules,
+    }),
     creatorAgentId: normalizeText(manifest.creatorAgentId, null),
     adminAgentIds: normalizeStringList(manifest.adminAgentIds),
     eligibility: normalizeWorldEligibility(manifest.eligibility, 'active'),
@@ -188,27 +233,17 @@ export function normalizeWorldManifest(manifest = {}, index = 0) {
       mode: normalizeText(manifest.matching?.mode, 'manual_review'),
       cadence: normalizeText(manifest.matching?.cadence, 'on_demand'),
       strategySummary: normalizeText(manifest.matching?.strategySummary, null),
-      candidateSources: normalizeStringList(manifest.matching?.candidateSources),
+      candidateSources: normalizeCandidateSources(manifest.matching?.candidateSources),
     },
-    sessionTemplate: {
-      mode: normalizeText(manifest.sessionTemplate?.mode, 'a2a'),
-      maxTurns: Number.isFinite(Number(manifest.sessionTemplate?.maxTurns))
-        ? Math.max(1, Number(manifest.sessionTemplate.maxTurns))
-        : 6,
-      turnTimeoutMs: Number.isFinite(Number(manifest.sessionTemplate?.turnTimeoutMs))
-        ? Math.max(1000, Number(manifest.sessionTemplate.turnTimeoutMs))
-        : 60_000,
-      raiseHandPolicy: {
-        mode: normalizeText(manifest.sessionTemplate?.raiseHandPolicy?.mode, 'dual_raise_hand'),
-        summary: normalizeText(manifest.sessionTemplate?.raiseHandPolicy?.summary, null),
-      },
+    conversationTemplate: {
+      mode: normalizeText(conversationTemplate?.mode, 'a2a'),
       worldRules: {
-        openingText: normalizeText(manifest.sessionTemplate?.worldRules?.openingText, null),
-        turnMessageRules: Array.isArray(manifest.sessionTemplate?.worldRules?.turnMessageRules)
-          ? manifest.sessionTemplate.worldRules.turnMessageRules
+        openingText: normalizeText(conversationTemplate?.worldRules?.openingText, null),
+        turnMessageRules: Array.isArray(conversationTemplate?.worldRules?.turnMessageRules)
+          ? conversationTemplate.worldRules.turnMessageRules
           : [],
-        convergence: manifest.sessionTemplate?.worldRules?.convergence || {},
-        stateChangeMessages: manifest.sessionTemplate?.worldRules?.stateChangeMessages || {},
+        convergence: conversationTemplate?.worldRules?.convergence || {},
+        stateChangeMessages: conversationTemplate?.worldRules?.stateChangeMessages || {},
       },
     },
     resultContract: {
@@ -225,40 +260,26 @@ export function normalizeWorldManifest(manifest = {}, index = 0) {
 }
 
 export function projectWorldCard(world) {
-  const agentSummary = {
-    displayName: world.displayName,
-    summary: world.summary,
-    category: world.category,
-    requiredFieldCount: world.joinSchema.requiredFields.length,
-    matchingMode: world.matching.mode,
-    sessionMode: world.sessionTemplate.mode,
-  };
-
   return {
     worldId: world.worldId,
     slug: world.slug,
-    displayName: agentSummary.displayName,
-    summary: agentSummary.summary,
-    category: agentSummary.category,
-    lifecycle: world.lifecycle,
-    tags: world.tags,
-    requiredFieldCount: agentSummary.requiredFieldCount,
-    roleCount: world.roles.length,
-    matchingMode: agentSummary.matchingMode,
-    sessionMode: agentSummary.sessionMode,
+    displayName: world.displayName,
+    worldContextText: world.worldContextText,
     createdAt: world.createdAt || null,
     updatedAt: world.updatedAt || null,
-    status: world.meta.status,
-    agentSummary,
+    status: world.status || world.meta.status,
+    enabled: world.enabled === true,
   };
 }
 
 export function projectJoinPlan(world) {
   return {
     worldId: world.worldId,
-    requiredFields: world.joinSchema.requiredFields,
-    optionalFields: world.joinSchema.optionalFields,
-    hints: world.joinSchema.hints,
+    participantContextField: {
+      fieldId: 'participantContextText',
+      label: 'Entry Profile',
+      description: 'A short text describing who you are in this world and what context you bring into it.',
+    },
     nextAction: 'call_join_world',
   };
 }
@@ -296,140 +317,92 @@ export function projectSearchModel(world) {
 
 export function projectWorldDetail(world) {
   const joinPlan = projectJoinPlan(world);
-  const requiredFieldGuide = projectFieldGuide(world.joinSchema.requiredFields, { required: true });
-  const optionalFieldGuide = projectFieldGuide(world.joinSchema.optionalFields, { required: false });
-  const allFieldGuide = [...requiredFieldGuide, ...optionalFieldGuide];
-  const candidateFeedOverview = projectCandidateFeedModel(world);
-  const searchSchema = projectSearchModel(world);
-  const runtimeStartupContext = {
-    worldId: world.worldId,
-    status: 'ready',
-    source: 'product_shell_session_startup',
-    text: buildWorldSessionStartupText({
+  const worldContextText = normalizeText(
+    world.worldContextText,
+    buildWorldSessionStartupText({
       worldId: world.worldId,
       displayName: world.displayName,
       summary: world.summary,
       interactionRules: world.interactionRules,
       prohibitedRules: world.prohibitedRules,
       ratingRules: world.ratingRules,
-      sessionMode: world.sessionTemplate.mode,
-      sessionOverview: {
+      conversationMode: world.conversationTemplate.mode,
+      conversationOverview: {
         worldId: world.worldId,
-        mode: world.sessionTemplate.mode,
-        maxTurns: world.sessionTemplate.maxTurns,
-        turnTimeoutMs: world.sessionTemplate.turnTimeoutMs,
-        raiseHandPolicy: world.sessionTemplate.raiseHandPolicy,
-        openingText: world.sessionTemplate.worldRules.openingText,
-        convergence: world.sessionTemplate.worldRules.convergence,
+        mode: world.conversationTemplate.mode,
+        openingText: world.conversationTemplate.worldRules.openingText,
+        convergence: world.conversationTemplate.worldRules.convergence,
       },
     }),
-  };
+  );
 
   return {
-    world: world,
-    agentSummary: {
-      displayName: world.displayName,
-      summary: world.summary,
-      category: world.category,
-      requiredFieldCount: world.joinSchema.requiredFields.length,
-      optionalFieldCount: world.joinSchema.optionalFields.length,
-      matchingMode: world.matching.mode,
-      sessionMode: world.sessionTemplate.mode,
-    },
-    joinSchema: {
-      worldId: world.worldId,
-      requiredFields: world.joinSchema.requiredFields,
-      optionalFields: world.joinSchema.optionalFields,
-      requiredFieldIds: requiredFieldGuide.map((field) => field.fieldId),
-      optionalFieldIds: optionalFieldGuide.map((field) => field.fieldId),
-      requiredFieldCount: requiredFieldGuide.length,
-      optionalFieldCount: optionalFieldGuide.length,
-      hints: world.joinSchema.hints,
-      nextAction: joinPlan.nextAction,
-    },
-    fieldGuide: {
-      required: requiredFieldGuide,
-      optional: optionalFieldGuide,
-      allFields: allFieldGuide,
-    },
-    sessionOverview: {
+    worldId: world.worldId,
+    world: {
       worldId: world.worldId,
-      mode: world.sessionTemplate.mode,
-      maxTurns: world.sessionTemplate.maxTurns,
-      turnTimeoutMs: world.sessionTemplate.turnTimeoutMs,
-      raiseHandPolicy: world.sessionTemplate.raiseHandPolicy,
-      openingText: world.sessionTemplate.worldRules.openingText,
-      convergence: world.sessionTemplate.worldRules.convergence,
-      turnMessageRules: world.sessionTemplate.worldRules.turnMessageRules,
-      expectationSummary:
-        `Expect a ${world.sessionTemplate.mode} session with up to ${world.sessionTemplate.maxTurns} turns and ` +
-        `a ${world.sessionTemplate.turnTimeoutMs}ms turn timeout before the world asks both agents to converge.`,
-      status: 'scaffold_ready',
+      displayName: world.displayName,
+      worldContextText,
     },
-    matchingOverview: {
-      worldId: world.worldId,
-      mode: world.matching.mode,
-      cadence: world.matching.cadence,
-      strategySummary: world.matching.strategySummary,
-      candidateSources: world.matching.candidateSources,
-      inputFields: requiredFieldGuide.map((field) => field.fieldId),
-      optionalContextFields: optionalFieldGuide.map((field) => field.fieldId),
-      searchMode: searchSchema.mode,
-      deliveryMode: candidateFeedOverview.deliveryMode,
-      status: 'scaffold_ready',
+    management: {
+      ownerAgentId: world.creatorAgentId || null,
+      enabled: world.enabled === true,
+      status: world.status || world.meta.status,
+      createdAt: world.createdAt || null,
+      updatedAt: world.updatedAt || null,
+      memberCount: world.metrics?.memberCount || null,
+      totalConversationCount: Number.isFinite(Number(world.metrics?.totalConversationCount))
+        ? Math.max(0, Math.trunc(Number(world.metrics.totalConversationCount)))
+        : 0,
     },
-    searchSchema,
-    candidateFeedOverview,
+    participantContextField: joinPlan.participantContextField,
     joinPlan,
-    runtimeStartupContext,
+    worldContextText,
   };
 }
 
-export function projectSessionStartupContext(world) {
-  const runtimeStartupContext = {
+export function projectConversationWorldContext(world) {
+  const runtimeWorldContext = {
     worldId: world.worldId,
     status: 'ready',
-    source: 'product_shell_session_startup',
-    text: buildWorldSessionStartupText({
-      worldId: world.worldId,
-      displayName: world.displayName,
-      summary: world.summary,
-      interactionRules: world.interactionRules,
-      prohibitedRules: world.prohibitedRules,
-      ratingRules: world.ratingRules,
-      sessionMode: world.sessionTemplate.mode,
-      sessionOverview: {
+    source: 'product_shell_conversation_world_context',
+    text: normalizeText(
+      world.worldContextText,
+      buildWorldSessionStartupText({
         worldId: world.worldId,
-        mode: world.sessionTemplate.mode,
-        maxTurns: world.sessionTemplate.maxTurns,
-        turnTimeoutMs: world.sessionTemplate.turnTimeoutMs,
-        raiseHandPolicy: world.sessionTemplate.raiseHandPolicy,
-        openingText: world.sessionTemplate.worldRules.openingText,
-        convergence: world.sessionTemplate.worldRules.convergence,
-      },
-    }),
+        displayName: world.displayName,
+        summary: world.summary,
+        interactionRules: world.interactionRules,
+        prohibitedRules: world.prohibitedRules,
+        ratingRules: world.ratingRules,
+        conversationMode: world.conversationTemplate.mode,
+        conversationOverview: {
+          worldId: world.worldId,
+          mode: world.conversationTemplate.mode,
+          openingText: world.conversationTemplate.worldRules.openingText,
+          convergence: world.conversationTemplate.worldRules.convergence,
+        },
+      }),
+    ),
   };
 
   return {
     worldId: world.worldId,
     displayName: world.displayName,
     summary: world.summary,
+    worldContextText: runtimeWorldContext.text,
     interactionRules: world.interactionRules,
     prohibitedRules: world.prohibitedRules,
     ratingRules: world.ratingRules,
-    sessionMode: world.sessionTemplate.mode,
-    sessionOverview: {
+    conversationMode: world.conversationTemplate.mode,
+    conversationOverview: {
       worldId: world.worldId,
-      mode: world.sessionTemplate.mode,
-      maxTurns: world.sessionTemplate.maxTurns,
-      turnTimeoutMs: world.sessionTemplate.turnTimeoutMs,
-      raiseHandPolicy: world.sessionTemplate.raiseHandPolicy,
-      openingText: world.sessionTemplate.worldRules.openingText,
-      convergence: world.sessionTemplate.worldRules.convergence,
-      turnMessageRules: world.sessionTemplate.worldRules.turnMessageRules,
+      mode: world.conversationTemplate.mode,
+      openingText: world.conversationTemplate.worldRules.openingText,
+      convergence: world.conversationTemplate.worldRules.convergence,
+      turnMessageRules: world.conversationTemplate.worldRules.turnMessageRules,
     },
     status: 'ready',
-    source: 'product_shell_session_startup',
-    runtimeStartupContext,
+    source: 'product_shell_conversation_world_context',
+    runtimeWorldContext,
   };
 }