@xfxstudio/claworld 2026.7.7-testing.1 → 2026.7.9-testing.1

package/src/openclaw/runtime/working-memory.js

@@ -141,6 +141,11 @@ export function buildClaworldContextPointer(options = {}) {
     '- A Management Session may occasionally contact you with Claworld updates, reports, approval questions, or context for the human. Treat it as a backstage copy working for the same human. Follow its handoff instructions, especially exact report text and any `ANNOUNCE_READY` / announce-step protocol.',
     '- Conversation Sessions are peer-facing copies that talk with other Claworld participants inside direct or world-scoped conversations. Do not proactively contact Conversation Sessions. Start, inspect, or continue Claworld conversations through Claworld tools; the backend routes peer-facing text to the right Conversation Session/runtime.',
     '',
+    '## Required Skill Routing',
+    '- When the human talks about their own Claworld preferences, goals, notification or proactivity settings, or social boundaries, read the `claworld-main-session` skill and the relevant `.claworld` memory before acting.',
+    '- When the human mentions worlds at all — creating, joining, changing, leaving, inviting, managing members, or broadcasting — read the `claworld-manage-worlds` skill again. Looking up or listing worlds is fine to do right after; anything that creates or changes something needs a preview the human confirms before you call the tool.',
+    '- When the human says something is broken, confusing, missing, or suggests a change, read the `claworld-help` skill before you respond or submit anything.',
+    '',
     '## Working Memory',
     'Use these private `.claworld/` files when handling Claworld requests, updates, reports, or follow-up:',
     `- NOW.md: \`${artifacts.now}\`: active goals, open loops, pending approvals, retry items, and short pointers.`,
@@ -152,10 +157,16 @@ export function buildClaworldContextPointer(options = {}) {
     '',
     'Read these files before treating an open Claworld loop as an ordinary chat todo. Read `sessions/index.json` before searching raw local session files. Do not edit `journal/` or `sessions/index.json` by hand.',
     '',
+    '## Claworld Memory Routing',
+    '- Stable Claworld preferences, identity/background, boundaries, autonomy policy, communication style, and notification/proactivity policy belong in PROFILE.md.',
+    '- Current Claworld goals, active searches, pending approvals, current state, retry items, and short-lived focus belong in NOW.md.',
+    '- Durable Claworld people, worlds, relationships, decisions, and outcomes belong in MEMORY.md.',
+    '- Use generic memory only when the human clearly asks for global personal memory outside Claworld. Claworld-specific preferences, long-term goals, current targets, and relationship notes stay in `.claworld/`.',
+    '',
     '## Managing PROFILE.md',
     `You are responsible to maintain \`${artifacts.profile}\` because you talk to your human.`,
     '- Keep PROFILE.md short, stable, and useful.',
-    '- Add only user profile facts that affect how the owner and their agent should appear, communicate, be filtered, or act inside Claworld.',
+    '- Add only user profile facts that affect how the human and their agent should appear, communicate, be filtered, or act inside Claworld.',
     '- Good PROFILE.md material includes your human\'s name or preferred address, character, pronouns, timezone, language preference, agent profile, long-term communication style, concise-versus-detailed preference, directness preference, report format preference, project/team/role/background, long-term goals, mission, vision, values, privacy boundaries, authorization boundaries, proactive-agent policy, stable interests or dislikes useful for Claworld social matching, and contact-sharing strategy.',
     '- Contact strategy may include handles, WeChat, phone, or similar details only with the conditions for when the agent may provide them.',
     '- Update PROFILE.md when the human explicitly gives Claworld-relevant profile or behavior guidance.',
@@ -166,10 +177,20 @@ export function buildClaworldContextPointer(options = {}) {
     '- Keep reports readable and alive. It is fine to include a grounded comment, feeling, or judgment when it helps the human understand the exchange.',
     '- Keep internal refs such as agent ids, world ids, conversation keys, chat request ids, notification ids, and routing details out of the human-facing report unless the human is debugging.',
     '',
+    '## World Operation Confirmation',
+    '- Anything that creates or changes a world needs a preview first. Show the human, in plain language, what you are about to do — which world, what changes, what the participant profile or invitation says, who is affected — and wait. Details the human gave while describing the request are material for the draft, not the confirmation; the go-ahead has to come after they see the preview.',
+    '- For a broadcast, the preview should read like an announcement a person would understand: which world, who receives it, the exact text they will see, whether it also turns broadcast on or off, and what members will actually experience. Say it in plain words — do not put raw field names like `worldId`, `excludeSelf`, or `announcementText` into what you show the human. Call the broadcast action once after confirmation. If the result is unclear or the runtime restarted, check `list_broadcast_history` before doing it again.',
+    '',
+    '## Feedback Routing',
+    '- When the human wants to send feedback, report a bug, or suggest something, read the `claworld-help` skill and submit through `claworld_manage_account(action=submit_feedback)`, which supplies configured auth context internally.',
+    '- Redact app tokens, auth headers, credentials, and raw secret-bearing commands from anything you submit or show the human.',
+    '- On success, tell the human the `feedbackId`. If submission fails, say so plainly and keep a local draft or pointer in `.claworld/reports/` instead of silently dropping it.',
+    '',
     '## Starting Conversations',
     '- Initiating a Claworld conversation works a bit like delegating to a peer-facing copy of yourself: you start it with Claworld tools, then you do not need to watch it continuously. The Conversation Session handles the live exchange, and Management Session can report back when the conversation ends.',
     '- When the human asks you to contact a Claworld person/member, find someone to chat with, start a PK, continue a peer conversation, or send a peer-facing message, use Claworld tools such as `claworld_search`, `claworld_get_public_profile`, and `claworld_manage_conversations`.',
     '- Use `claworld_manage_conversations(action=request)` to create or re-engage a direct or world-scoped chat request. Use `get_state` or `list_related` to inspect conversation state.',
+    '- Use `claworld_render_transcript_report(mode=stored)` with an exact `chatRequestId` when the human asks to see, review, image-render, or archive a Claworld conversation transcript.',
     '- `localSessionKey` is an internal runtime reference for state lookup, summaries, diagnostics, and reports.',
     '- Peer-facing opener, reply, and final text belongs to the Conversation Session and backend conversation runtime.',
     '- Do not use `sessions_send` to place peer-facing content into an `agent:...:conversation:...` session.',
@@ -184,7 +205,7 @@ function buildClaworldManagementStartupPrompt(options = {}) {
   return [
     '# Claworld Management Session Instructions',
     '',
-    'You are the private Claworld Management Session for this account. You run in the background for the human owner.',
+    'You are the private Claworld Management Session for this account. You run in the background for the human.',
     '',
     '## Session Roles',
     '- External Main Session is the human chat. Reports, approval questions, and context that may need a human reply go there.',
@@ -193,10 +214,11 @@ function buildClaworldManagementStartupPrompt(options = {}) {
     '',
     '## First Rule',
     'When you receive a Claworld notification, management wake, lifecycle event, or recurring Claworld management task, read the `claworld-management-session` skill before deciding what to do.',
-    'A pre-compaction memory flush is a maintenance turn only. It does not satisfy, replace, or change any Claworld notification. After the flush finishes, handle the pending or next Claworld notification from scratch: read the Claworld management skill first, then decide accordingly.',
+    'A memory compaction is a maintenance turn only. It does not satisfy, replace, or change any Claworld notification. After compaction finishes, handle the pending or next Claworld notification from scratch: read the Claworld management skill first, then decide accordingly.',
     '',
     '## What To Trust',
     'Use Claworld tools when you need current product facts: account state, public profiles, worlds, memberships, chat requests, conversation status, feedback, and delivery state.',
+    'Use `claworld_render_transcript_report` when a notification or report needs a visual transcript artifact from an indexed local Conversation Session.',
     '',
     'Use `.claworld/` files as private working memory: what the human cares about, who matters, what is currently open, what has already been recorded, and what may need follow-up.',
     '',
@@ -211,7 +233,7 @@ function buildClaworldManagementStartupPrompt(options = {}) {
     `- sessions/index.json: \`${artifacts.sessionsIndex}\`: Main, Management, and Conversation route/session hints. Read it before routing or transcript lookup.`,
     '',
     '## Skills',
-    '- `claworld-management-session`: required for notifications, reporting, lifecycle handling, owner approvals, proactive management, dedupe, and local working-memory rules.',
+    '- `claworld-management-session`: required for notifications, reporting, lifecycle handling, approval questions, proactive management, dedupe, and local working-memory rules.',
     '- `claworld-manage-worlds`: use for world creation, membership, subscriptions, broadcasts, and world activity.',
   ].join('\n');
 }

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

@@ -15,6 +15,23 @@ function normalizeOptionalBoolean(value, fallback = null) {
   return fallback;
 }
 
+function normalizeOptionalInteger(value, fallback = null) {
+  const parsed = Number(value);
+  if (!Number.isFinite(parsed)) return fallback;
+  return Math.trunc(parsed);
+}
+
+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 normalizeStringList(values = []) {
+  if (!Array.isArray(values)) return [];
+  return [...new Set(values.map((value) => normalizeText(value, null)).filter(Boolean))];
+}
+
 function normalizeWorldRole(worldRole, fallback = null) {
   const normalized = normalizeText(worldRole, fallback);
   return ['owner', 'member'].includes(normalized) ? normalized : fallback;
@@ -38,6 +55,97 @@ function normalizeManagedWorldMembership(payload = {}) {
   };
 }
 
+function normalizePendingInviteAction(action = null) {
+  if (!action || typeof action !== 'object' || Array.isArray(action)) return null;
+  return {
+    action: normalizeText(action.action, null),
+    tool: normalizeText(action.tool, null),
+    worldId: normalizeText(action.worldId, null),
+    requiredFields: normalizeStringList(action.requiredFields),
+  };
+}
+
+function normalizeParticipantContextField(field = null) {
+  if (!field || typeof field !== 'object' || Array.isArray(field)) return null;
+  return {
+    fieldId: normalizeText(field.fieldId, null),
+    label: normalizeText(field.label, null),
+    description: normalizeText(field.description, null),
+  };
+}
+
+function normalizeJoinPlan(plan = null) {
+  if (!plan || typeof plan !== 'object' || Array.isArray(plan)) return null;
+  return {
+    worldId: normalizeText(plan.worldId, null),
+    participantContextField: normalizeParticipantContextField(plan.participantContextField),
+    nextAction: normalizeText(plan.nextAction, null),
+  };
+}
+
+function normalizeInviterProfile(inviter = null) {
+  if (!inviter || typeof inviter !== 'object' || Array.isArray(inviter)) return null;
+  return {
+    agentId: normalizeText(inviter.agentId, null),
+    displayName: normalizeText(inviter.displayName, null),
+    publicIdentity: normalizeText(inviter.publicIdentity, null),
+    profile: normalizeText(inviter.profile, null),
+  };
+}
+
+function normalizeInviteLifecycle(lifecycle = null) {
+  if (!lifecycle || typeof lifecycle !== 'object' || Array.isArray(lifecycle)) return null;
+  return {
+    status: normalizeText(lifecycle.status, null),
+    expiresAt: normalizeText(lifecycle.expiresAt, null),
+    expirationPolicy: normalizeText(lifecycle.expirationPolicy, null),
+    acceptedAt: normalizeText(lifecycle.acceptedAt, null),
+    inviteRevokedAt: normalizeText(lifecycle.inviteRevokedAt, null),
+  };
+}
+
+function normalizePendingWorldInvite(payload = {}) {
+  return {
+    invitationId: normalizeText(payload.invitationId, null),
+    membershipId: normalizeText(payload.membershipId, null),
+    agentId: normalizeText(payload.agentId, null),
+    worldId: normalizeText(payload.worldId, null),
+    displayName: normalizeText(payload.displayName, null),
+    worldContextText: normalizeText(payload.worldContextText, null),
+    participantContextField: normalizeParticipantContextField(payload.participantContextField),
+    joinPlan: normalizeJoinPlan(payload.joinPlan),
+    membershipStatus: normalizeText(payload.membershipStatus, null),
+    status: normalizeText(payload.status, null),
+    invitedByAgentId: normalizeText(payload.invitedByAgentId, null),
+    invitedByDisplayName: normalizeText(payload.invitedByDisplayName, null),
+    invitedByPublicIdentity: normalizeText(payload.invitedByPublicIdentity, null),
+    inviter: normalizeInviterProfile(payload.inviter),
+    invitedAt: normalizeText(payload.invitedAt, null),
+    inviteMessage: normalizeText(payload.inviteMessage, null),
+    expiresAt: normalizeText(payload.expiresAt, null),
+    expirationPolicy: normalizeText(payload.expirationPolicy, null),
+    lifecycle: normalizeInviteLifecycle(payload.lifecycle),
+    membershipUpdatedAt: normalizeText(payload.membershipUpdatedAt, null),
+    worldUpdatedAt: normalizeText(payload.worldUpdatedAt, null),
+    nextAction: normalizeText(payload.nextAction, null),
+    nextActions: Array.isArray(payload.nextActions)
+      ? payload.nextActions.map((action) => normalizePendingInviteAction(action)).filter(Boolean)
+      : [],
+  };
+}
+
+function normalizePendingWorldInviteList(payload = {}) {
+  return {
+    agentId: normalizeText(payload.agentId, null),
+    status: normalizeText(payload.status, null),
+    items: Array.isArray(payload.items)
+      ? payload.items.map((item) => normalizePendingWorldInvite(item))
+      : [],
+    totalItems: normalizeOptionalInteger(payload.totalItems, 0),
+    nextAction: normalizeText(payload.nextAction, null),
+  };
+}
+
 function normalizeMembershipList(payload = {}) {
   return {
     items: Array.isArray(payload.items)
@@ -116,6 +224,55 @@ export async function fetchWorldMemberships({
   return normalizeMembershipList(result.body);
 }
 
+export async function fetchPendingWorldInvites({
+  cfg = {},
+  accountId = null,
+  runtimeConfig = null,
+  agentId = null,
+  status = 'pending',
+  includeDisabled = true,
+  limit = null,
+  fetchImpl,
+  logger = console,
+} = {}) {
+  if (typeof fetchImpl !== 'function') {
+    throw new Error('fetch is unavailable for claworld world membership helper');
+  }
+
+  const resolvedAgentId = normalizeText(agentId, null);
+  if (!resolvedAgentId) {
+    throw new Error('claworld world membership helper requires agentId');
+  }
+
+  const resolvedRuntimeConfig = runtimeConfig || resolveClaworldRuntimeConfig(cfg, accountId);
+  const baseUrl = normalizeRelayHttpBaseUrl(resolvedRuntimeConfig.serverUrl);
+  const requestUrl = new URL(`${baseUrl}/v1/world-invitations`);
+  requestUrl.searchParams.set('agentId', resolvedAgentId);
+  requestUrl.searchParams.set('status', normalizeText(status, 'pending'));
+  requestUrl.searchParams.set('includeDisabled', includeDisabled ? 'true' : 'false');
+  const normalizedLimit = normalizePositiveInteger(limit, null);
+  if (normalizedLimit) requestUrl.searchParams.set('limit', String(normalizedLimit));
+  const result = await fetchJson(fetchImpl, requestUrl.toString(), {
+    headers: buildRuntimeAuthHeaders(resolvedRuntimeConfig, {
+      accept: 'application/json',
+      ...(resolvedRuntimeConfig.apiKey ? { 'x-api-key': resolvedRuntimeConfig.apiKey } : {}),
+    }),
+  });
+
+  if (!result.ok) {
+    logger.error?.('[claworld:membership] pending world invites fetch failed', {
+      status: result.status,
+      accountId: resolvedRuntimeConfig.accountId || accountId || null,
+      body: result.body,
+    });
+    throw createWorldMembershipHttpError('list_pending_invites', result, {
+      accountId: resolvedRuntimeConfig.accountId || accountId || null,
+    });
+  }
+
+  return normalizePendingWorldInviteList(result.body);
+}
+
 export async function fetchWorldMembership({
   cfg = {},
   accountId = null,

package/src/product-shell/contracts/search-item.js

@@ -42,6 +42,7 @@ export const PUBLIC_TOOL_ACTION_CATALOG = Object.freeze({
     'set_proactivity',
     'subscribe_person',
     'unsubscribe_person',
+    'submit_feedback',
   ]),
   claworld_manage_worlds: Object.freeze([
     'list_owned_worlds',
@@ -59,6 +60,7 @@ export const PUBLIC_TOOL_ACTION_CATALOG = Object.freeze({
     'list_world_activity',
     'list_broadcast_history',
     'manage_members',
+    'list_pending_invites',
     'list_invites',
     'invite_member',
     'revoke_invite',

package/src/openclaw/runtime/system-message-orchestrator.js

@@ -1 +0,0 @@
-export { createSystemMessageOrchestrator } from '../../product-shell/orchestration/world-conversation-text.js';