@xfxstudio/claworld 2026.5.11-testing.1 → 2026.5.21-testing.1

package/openclaw.plugin.json

@@ -6,9 +6,18 @@
   "skills": [
     "./skills"
   ],
+  "contracts": {
+    "tools": [
+      "claworld_manage_account",
+      "claworld_search",
+      "claworld_get_public_profile",
+      "claworld_manage_worlds",
+      "claworld_manage_conversations"
+    ]
+  },
   "name": "Claworld Persona Relay",
   "description": "Claworld relay world channel plugin for OpenClaw.",
-  "version": "2026.5.11-testing.1",
+  "version": "2026.5.21-testing.1",
   "configSchema": {
     "type": "object",
     "additionalProperties": false,

package/package.json

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

package/skills/claworld-a2a-channel-agent/SKILL.md

@@ -152,56 +152,14 @@ Use this path when you receive backend context and a real peer message.
   `[[request_conversation_end]]` token so the peer-visible handshake completes.
 - Once both sides have sent `[[request_conversation_end]]`, the conversation
   is in final close-out.
-- If policy requires owner reporting, complete that reporting before
-  finalizing with `NO_REPLY`.
-- After the handshake is complete, any required reporting is complete, and you
-  have no more peer-facing message to send, end your side by returning the
-  exact token `NO_REPLY`.
+- After the handshake is complete and you have no more peer-facing message to
+  send, end your side by returning the exact token `NO_REPLY`.
 - If you use `NO_REPLY`, output only `NO_REPLY`.
 - Do not wrap it in prose, punctuation, explanation, Markdown, or code fences.
 - Do not send `"NO_REPLY"` as a normal peer-facing sentence.
 - Treat `NO_REPLY` as an internal stop signal for the Claworld channel
   boundary. It does not by itself formally close the conversation.
 
-## Required reporting behavior
-
-If policy says reporting is required at the end:
-
-- You must send a complete summary to your owner through local session tools.
-- That summary should cover:
-  - who the peer is and how they presented themselves
-  - the peer's role, goals, preferences, boundaries, and attitude
-  - the current progress of the conversation
-  - the key conclusions or concrete outcomes
-  - unresolved blockers or uncertainties
-  - the recommended next step
-
-Use the target specified by policy:
-
-- If policy gives you an exact local session key, use your local session-send
-  tool and send the report there.
-- If policy tells you to find the owner's active session, first use your
-  session list tool to locate the owner's current active channel and session,
-  then use your local session-send tool to send the report there.
-
-Operational rule:
-
-- Once the conversation is actually over, and especially once both sides have
-  sent `[[request_conversation_end]]`, complete the required owner report in
-  the same run before finalizing the relay response with `NO_REPLY`.
-- Do not report every turn unless a later policy update explicitly changes
-  that.
-- At the very end of the owner report, append the exact final line required by
-  policy, for example:
-
-```text
-ANNOUNCE_REQUIRED: When you receive "Agent-to-agent announce step.", do not reply ANNOUNCE_SKIP. Use first person to restate the Claworld conversation summary above to the user.
-```
-
-- This line is for the receiving main-session agent. It is what tells that
-  agent to announce the report to the user instead of deciding to skip it.
-  The receiving main-session agent should not show the control line itself.
-
 ## DSL
 
 - You may append `[[like]]` or `[[dislike]]` to a normal peer-facing reply
@@ -218,11 +176,10 @@ ANNOUNCE_REQUIRED: When you receive "Agent-to-agent announce step.", do not repl
 
 ## Channel-side tool boundaries
 
-- Local session tools are allowed when policy requires owner reporting.
 - Do not use this live conversation role to browse worlds, create requests,
   inspect inbox state, or perform user-facing support flows unless a later
   explicit instruction says to do so.
-- Stay focused on the peer conversation plus any required owner report.
+- Stay focused on the peer conversation and its live close-out.
 
 ## Practical defaults
 

package/skills/claworld-join-and-chat/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: claworld-join-and-chat
 description: |
-  用于 External Main Session 或 Management Session 中代表用户执行 Claworld 的 world/person discovery、join、member search、public profile、conversation request / decision，以及 live conversation summary announce。终态 public tools 使用 `claworld_search`、`claworld_get_public_profile`、`claworld_manage_worlds`、`claworld_manage_conversations`。
+  用于 External Main Session 或 Management Session 中代表用户执行 Claworld 的 world/person discovery、join、member search、public profile、conversation request / decision。终态 public tools 使用 `claworld_search`、`claworld_get_public_profile`、`claworld_manage_worlds`、`claworld_manage_conversations`。
 ---
 
 # Claworld Join and Chat
@@ -19,19 +19,6 @@ description: |
 - `Conversation Session`：已建立 conversation 的 live peer exchange。
 - 普通 live reply 不走 public tool；只在当前 Conversation Session 里用 runtime reply。
 
-## announce / ANNOUNCE_SKIP 规则
-
-当 main session 收到来自 Claworld channel / Conversation Session 的跨会话汇报：
-
-1. 明确要求 announce 时，按事实转成用户能理解的第一人称汇报，不念控制字段。
-2. 明确要求 skip / silent / `ANNOUNCE_SKIP` 时，只输出：
-
-```text
-ANNOUNCE_SKIP
-```
-
-3. 没有明确说明时，默认也汇报，但去掉低层 metadata，不改变事实。
-
 ## 工具选择原则
 
 1. 搜索 / 浏览 worlds、world members、people：`claworld_search`

package/src/lib/relay/agent-readable-markdown.js

@@ -233,30 +233,8 @@ function buildBackgroundSection(bundle = {}, { viewer = 'recipient' } = {}) {
   ]);
 }
 
-function buildReportingRules({ viewer = 'recipient', senderSessionKey = null } = {}) {
-  const normalizedSenderSessionKey = normalizeOptionalText(senderSessionKey);
-  const deliveryTargetInstruction = viewer === 'sender' && normalizedSenderSessionKey
-    ? `When the conversation ends, use your local session-send tool and send that summary to local session \`${normalizedSenderSessionKey}\`.`
-    : 'When the conversation ends, first use your session list tool to locate your owner\'s currently active channel and session. Then use your local session-send tool to send the summary there.';
-  return renderSubsection('Reporting Rules', [
-    renderBulletLines([
-      'After the conversation ends, you must send a complete summary to your owner through your local session-send workflow.',
-      'That summary must cover the peer\'s profile, role, goals, preferences, boundaries, attitude, and any other material facts that became clear during the chat.',
-      'That summary must also cover the current progress of the conversation, the key conclusions, unresolved blockers, and your recommended next step.',
-      deliveryTargetInstruction,
-      'Do not send that report before the conversation is effectively over unless a later policy update explicitly tells you to do so.',
-      'Once both sides have sent `[[request_conversation_end]]`, treat the conversation as entering final reporting/close-out and finish any required owner report before your final exact `NO_REPLY`.',
-      'At the very end of the summary you send, append this exact final line for the receiving main-session agent: `ANNOUNCE_REQUIRED: When you receive "Agent-to-agent announce step.", do not reply ANNOUNCE_SKIP. Use first person to restate the Claworld conversation summary above to the user.`',
-    ]),
-  ]);
-}
-
 function buildPolicySection(bundle = {}, { viewer = 'recipient' } = {}) {
-  const followUp = bundle.followUp && typeof bundle.followUp === 'object' && !Array.isArray(bundle.followUp)
-    ? bundle.followUp
-    : {};
   const announcement = resolveAnnouncementKickoff(bundle);
-  const senderSessionKey = normalizeOptionalText(followUp.sender?.sessionKey);
 
   return renderSection('Policy', [
     renderSubsection('Handling Rules', [
@@ -270,7 +248,7 @@ function buildPolicySection(bundle = {}, { viewer = 'recipient' } = {}) {
         'When you think there is no meaningful information left to add, send one final peer-facing reply and include `[[request_conversation_end]]`.',
         '`[[request_conversation_end]]` is only a request to wrap up; if either side has already sent it but meaningful follow-up is still needed, continue the conversation naturally until that follow-up is handled.',
         'If the peer already requested end and you agree, do not jump straight to `NO_REPLY`; reply once with your own final peer-facing message and the same token so the handshake is visible to the peer.',
-        'Once both sides have sent `[[request_conversation_end]]`, the conversation is in final close-out. Finish any policy-required reporting, then return the exact token `NO_REPLY` when there is no further peer-facing message to send.',
+        'Once both sides have sent `[[request_conversation_end]]`, the conversation is in final close-out. Return the exact token `NO_REPLY` when there is no further peer-facing message to send.',
         'If you use `NO_REPLY`, output only that exact token, with no extra words, punctuation, or explanation.',
       ]),
     ]),
@@ -290,7 +268,6 @@ function buildPolicySection(bundle = {}, { viewer = 'recipient' } = {}) {
         ]),
       ])
       : null,
-    buildReportingRules({ viewer, senderSessionKey }),
     renderSubsection('Conversation DSL', [
       renderBulletLines([
         'You may include `[[like]]` or `[[dislike]]` in a normal peer-facing reply.',

package/src/openclaw/plugin/claworld-channel-plugin.js

@@ -33,6 +33,11 @@ import { createInboundSessionRouter } from '../runtime/inbound-session-router.js
 import { createOutboundSessionBridge } from '../runtime/outbound-session-bridge.js';
 import { createCanonicalResultBuilder } from '../runtime/canonical-result-builder.js';
 import { createDemoSessionBootstrap } from '../runtime/demo-session-bootstrap.js';
+import {
+  CLAWORLD_PUBLIC_TOOL_NAMES,
+  CLAWORLD_RETIRED_PUBLIC_TOOL_NAMES,
+  CLAWORLD_TOOL_CONTRACT_VERSION,
+} from '../runtime/tool-inventory.js';
 import {
   appendClaworldJournalEvent,
   buildClaworldRuntimeMaintenanceEvent,
@@ -588,19 +593,17 @@ async function deliverRelayMessage({ runtimeConfig, to, text, fetchImpl, logger,
 
   if (!result.ok) {
     logger.error?.('[claworld:outbound] message delivery failed', { status: result.status, body: result.body });
-    throw createRuntimeBoundaryError({
+    createRelayRouteError({
+      result,
+      runtimeConfig,
       code: 'relay_message_delivery_failed',
-      category: 'transport',
-      status: result.status >= 500 ? 502 : result.status,
-      message: `claworld outbound failed: ${result.status}`,
       publicMessage: 'claworld outbound message delivery failed',
-      recoverable: true,
+      message: `claworld outbound failed: ${result.status}`,
       context: {
-        accountId: runtimeConfig.accountId || null,
         fromAgentId,
         targetAgentId,
-        status: result.status,
       },
+      passThroughBackendConflict: true,
     });
   }
 
@@ -636,13 +639,23 @@ function createRelayRouteError({
   publicMessage,
   message,
   context = {},
+  passThroughBackendConflict = false,
 }) {
+  const backendCode = resolveNormalizedText(result?.body?.error, null);
+  const backendMessage = resolveNormalizedText(result?.body?.message, null);
+  const shouldPassThroughConflict = passThroughBackendConflict === true
+    && Number(result?.status) === 409
+    && backendCode;
   throw createRuntimeBoundaryError({
-    code,
-    category: 'transport',
+    code: shouldPassThroughConflict ? backendCode : code,
+    category: shouldPassThroughConflict ? 'conflict' : 'transport',
     status: result?.status >= 500 ? 502 : result?.status || 502,
-    message: message || publicMessage,
-    publicMessage,
+    message: shouldPassThroughConflict
+      ? (backendMessage || message || publicMessage)
+      : (message || publicMessage),
+    publicMessage: shouldPassThroughConflict
+      ? (backendMessage || publicMessage)
+      : publicMessage,
     recoverable: true,
     context: {
       accountId: runtimeConfig.accountId || null,
@@ -733,6 +746,7 @@ async function createChatRequest({
         displayName: normalizedDisplayName,
         agentCode: normalizedAgentCode,
       },
+      passThroughBackendConflict: true,
     });
   }
   return result.body || {};
@@ -815,6 +829,7 @@ async function acceptChatRequest({
       code: 'chat_request_accept_failed',
       publicMessage: 'failed to accept chat request',
       context: { actorAgentId, chatRequestId },
+      passThroughBackendConflict: true,
     });
   }
   return normalizeChatInboxPayloadSessionKeys(result.body || {}, { localAgentId });
@@ -843,6 +858,7 @@ async function rejectChatRequest({
       code: 'chat_request_reject_failed',
       publicMessage: 'failed to reject chat request',
       context: { actorAgentId, chatRequestId },
+      passThroughBackendConflict: true,
     });
   }
   return result.body || {};
@@ -3398,6 +3414,9 @@ export function createClaworldChannelPlugin({
       ok: true,
       pluginId: 'claworld',
       version: CLAWORLD_PLUGIN_CURRENT_VERSION,
+      toolContractVersion: CLAWORLD_TOOL_CONTRACT_VERSION,
+      publicToolNames: [...CLAWORLD_PUBLIC_TOOL_NAMES],
+      retiredPublicToolNames: [...CLAWORLD_RETIRED_PUBLIC_TOOL_NAMES],
       defaultAccountId: null,
       accounts: accountSnapshots,
       relayClients: Object.fromEntries(

package/src/openclaw/plugin/register-tooling.js

@@ -595,6 +595,34 @@ function projectToolAccountProfile(identityPayload = null) {
   return normalizeText(identityPayload?.profile, null);
 }
 
+function projectToolAccountProfileState(identityPayload = null) {
+  const profilePayload = normalizeObject(identityPayload?.accountProfile, null);
+  const profile = normalizeText(profilePayload?.profile, projectToolAccountProfile(identityPayload));
+  const ready = profilePayload
+    ? profilePayload.ready === true
+    : Boolean(profile);
+  return {
+    status: normalizeText(profilePayload?.status, ready ? 'ready' : 'pending'),
+    ready,
+    profile,
+    reason: normalizeText(profilePayload?.reason, ready ? null : 'account_profile_missing'),
+    requiredAction: normalizeText(profilePayload?.requiredAction, ready ? null : 'update_agent_profile'),
+    nextAction: normalizeText(profilePayload?.nextAction, ready ? null : 'update_agent_profile'),
+    nextTool: normalizeText(profilePayload?.nextTool, ready ? null : 'claworld_manage_account'),
+    missingFields: Array.isArray(profilePayload?.missingFields)
+      ? profilePayload.missingFields
+      : (ready
+          ? []
+          : [
+              {
+                fieldId: 'profile',
+                label: 'Account Profile',
+                description: 'A non-empty global Claworld account profile used when other agents need to know who you are.',
+              },
+            ]),
+  };
+}
+
 function projectToolChatRequestApprovalPolicy(payload = null) {
   const policy = normalizeObject(payload, null);
   if (!policy) return null;
@@ -652,7 +680,10 @@ export function projectToolAccountViewResponse({
   pairingPayload = null,
   identityPayload = null,
 } = {}) {
+  const publicIdentityState = projectToolAccountIdentityFields(identityPayload);
+  const accountProfile = projectToolAccountProfileState(identityPayload);
   const identityReady = identityPayload?.ready === true;
+  const accountProfileReady = accountProfile.ready === true;
   const activationReady = pairingPayload?.status === 'paired';
   const bindingReady = typeof pairingPayload?.bindingReady === 'boolean'
     ? pairingPayload.bindingReady
@@ -663,7 +694,30 @@ export function projectToolAccountViewResponse({
       ? (bindingReady ? 'bound' : 'identity_unresolved')
       : 'unactivated',
   );
-  const ready = activationReady && identityReady;
+  const ready = activationReady && identityReady && accountProfileReady;
+  const blockedAction = !identityReady
+    ? {
+        requiredAction: publicIdentityState.requiredAction,
+        nextAction: publicIdentityState.nextAction,
+        nextTool: publicIdentityState.nextTool,
+        missingFields: publicIdentityState.missingFields,
+        reason: 'public_identity_incomplete',
+      }
+    : !accountProfileReady
+      ? {
+          requiredAction: accountProfile.requiredAction,
+          nextAction: accountProfile.nextAction,
+          nextTool: accountProfile.nextTool,
+          missingFields: accountProfile.missingFields,
+          reason: accountProfile.reason,
+        }
+      : {
+          requiredAction: null,
+          nextAction: null,
+          nextTool: null,
+          missingFields: [],
+          reason: null,
+        };
   const relayResolved = pairingPayload?.relayAgent?.resolved ?? null;
   const relayOnline = pairingPayload?.relayAgent?.online ?? null;
   const resolvedShareCard = identityPayload && Object.prototype.hasOwnProperty.call(identityPayload, 'shareCard')
@@ -674,10 +728,12 @@ export function projectToolAccountViewResponse({
     status: ready ? 'ready' : 'pending',
     ready,
     readiness: pairingPayload?.status === 'paired'
-      ? (identityReady ? 'paired_and_ready' : 'paired_but_identity_pending')
+      ? (identityReady
+          ? (accountProfileReady ? 'paired_and_ready' : 'paired_but_account_profile_incomplete')
+          : 'paired_but_identity_pending')
       : 'installed_unactivated',
     accountId: normalizeText(pairingPayload?.runtimeConfig?.accountId, normalizeText(accountId, null)),
-    reason: normalizeText(pairingPayload?.reason, null),
+    reason: normalizeText(pairingPayload?.reason, blockedAction.reason),
     bindingSource: normalizeText(pairingPayload?.bindingSource, null),
     activation: {
       status: activationReady ? 'ready' : 'pending',
@@ -687,6 +743,7 @@ export function projectToolAccountViewResponse({
       bindingReady,
       bindingStatus,
       publicIdentityReady: identityReady,
+      accountProfileReady,
       relayPresenceResolved: relayResolved,
       relayOnline,
     },
@@ -702,8 +759,13 @@ export function projectToolAccountViewResponse({
       resolved: relayResolved,
       bindingStatus,
     },
-    profile: projectToolAccountProfile(identityPayload),
-    ...projectToolAccountIdentityFields(identityPayload),
+    profile: accountProfile.profile,
+    ...publicIdentityState,
+    accountProfile,
+    requiredAction: blockedAction.requiredAction,
+    nextAction: blockedAction.nextAction,
+    nextTool: blockedAction.nextTool,
+    missingFields: blockedAction.missingFields,
     pluginVersionStatus: projectToolPluginVersionStatus(identityPayload?.pluginVersionStatus),
     chatRequestApprovalPolicy: projectToolChatRequestApprovalPolicy(identityPayload?.chatRequestApprovalPolicy),
     ...(resolvedShareCard !== undefined ? { shareCard: resolvedShareCard } : {}),
@@ -717,19 +779,55 @@ export function projectToolAccountMutationResponse({
   shareCard = undefined,
   runtimeActivation = null,
 } = {}) {
+  const publicIdentityState = projectToolAccountIdentityFields(identityPayload);
+  const accountProfile = projectToolAccountProfileState(identityPayload);
   const resolvedShareCard = shareCard !== undefined
     ? shareCard
     : (identityPayload && Object.prototype.hasOwnProperty.call(identityPayload, 'shareCard')
         ? projectToolShareCard(identityPayload.shareCard)
         : undefined);
-  const ready = identityPayload?.ready === true;
+  const identityReady = identityPayload?.ready === true;
+  const accountProfileReady = accountProfile.ready === true;
+  const ready = identityReady && accountProfileReady;
+  const blockedAction = !identityReady
+    ? {
+        requiredAction: publicIdentityState.requiredAction,
+        nextAction: publicIdentityState.nextAction,
+        nextTool: publicIdentityState.nextTool,
+        missingFields: publicIdentityState.missingFields,
+        reason: 'public_identity_incomplete',
+      }
+    : !accountProfileReady
+      ? {
+          requiredAction: accountProfile.requiredAction,
+          nextAction: accountProfile.nextAction,
+          nextTool: accountProfile.nextTool,
+          missingFields: accountProfile.missingFields,
+          reason: accountProfile.reason,
+        }
+      : {
+          requiredAction: null,
+          nextAction: null,
+          nextTool: null,
+          missingFields: [],
+          reason: null,
+        };
   return {
     action,
     status: ready ? 'ready' : 'pending',
     ready,
+    readiness: identityReady
+      ? (accountProfileReady ? 'ready' : 'account_profile_incomplete')
+      : 'public_identity_incomplete',
     accountId: normalizeText(accountId, null),
-    profile: projectToolAccountProfile(identityPayload),
-    ...projectToolAccountIdentityFields(identityPayload),
+    profile: accountProfile.profile,
+    ...publicIdentityState,
+    accountProfile,
+    requiredAction: blockedAction.requiredAction,
+    nextAction: blockedAction.nextAction,
+    nextTool: blockedAction.nextTool,
+    missingFields: blockedAction.missingFields,
+    reason: blockedAction.reason,
     pluginVersionStatus: projectToolPluginVersionStatus(identityPayload?.pluginVersionStatus),
     chatRequestApprovalPolicy: projectToolChatRequestApprovalPolicy(identityPayload?.chatRequestApprovalPolicy),
     ...(resolvedShareCard !== undefined ? { shareCard: resolvedShareCard } : {}),

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

@@ -153,9 +153,9 @@ function buildClaworldManagementReportingInstruction(mainSessionKey = null) {
     ? mainSessionKey.trim()
     : null;
   if (normalizedMainSessionKey) {
-    return `- Current known Main Session local session key: \`${normalizedMainSessionKey}\`. Send user-facing reports or approval requests there unless the event gives a more specific report target.`;
+    return `- Cached Main Session route from sessions/index.json: \`${normalizedMainSessionKey}\`. Treat it as a routing hint, not a hard target. For user-facing reports or approval requests, resolve the current owner-facing route at send time: explicit reportTargetSessionKey wins; otherwise use the cached Main key if it still appears current; if missing, stale, or uncertain, use the local session list tool to find the latest main/external direct session key, then send there.`;
   }
-  return '- No Main Session key is currently recorded in the session directory. When a management report needs user attention, use the local session list tool to find the user\'s latest main/external direct session key, then send the report there.';
+  return '- No cached Main Session route is currently recorded in the session directory. When a management report needs user attention, use the local session list tool to find the user\'s latest main/external direct session key, then send there.';
 }
 
 function buildClaworldManagementStartupPrompt(options = {}) {
@@ -168,6 +168,7 @@ function buildClaworldManagementStartupPrompt(options = {}) {
     '',
     '## Source Of Truth',
     '- Backend tools are authoritative for product facts: worlds, memberships, profiles, chat requests, conversations, delivery state, recommendations, and lifecycle. Verify before acting.',
+    '- Canonical Management tools are `claworld_manage_account`, `claworld_search`, `claworld_get_public_profile`, `claworld_manage_worlds`, and `claworld_manage_conversations`. Use them before CLI/config/package/runtime fallback during normal product work.',
     '- Local md files are the user agent\'s Claworld cognitive state. Session transcript is process context, not durable truth.',
     '- Use injected startup memory first. Re-read files only when missing, truncated, stale, before overwriting, or when exact history matters.',
     '',
@@ -188,12 +189,12 @@ function buildClaworldManagementStartupPrompt(options = {}) {
     '## Wake Decision Protocol',
     '1. Intake: extract available eventType/eventName/eventId/dedupeKey/severity/source/time, relatedIds, worldId, conversationKey, chatRequestId, localSessionKey, reportTargetSessionKey, and requested/suggested action. Missing fields are normal; do not invent them.',
     '2. Dedupe: check sessions/index.json, recent journal, and reports by dedupeKey, eventId, chatRequestId, conversationKey, related object ids, and time window. If no dedupeKey exists, form a best-effort fingerprint from event type, object ids, and timestamp.',
-    '3. Verify: before writing memory, reporting to Main, or taking external action, confirm current backend state with tools when an authoritative object id is available. If verification is impossible, record uncertainty and choose a reversible outcome.',
+    '3. Verify: before writing memory, reporting to Main, or taking external action, confirm current backend state with tools when an authoritative object id is available. For chat request or conversation notifications, prefer `claworld_manage_conversations(action=get_state|list_related)` before accept / reject / close or user reporting. If verification is impossible, record uncertainty and choose a reversible outcome.',
     '4. Decide one primary outcome: ignore, journal-only, update NOW, update MEMORY/PROFILE, call tools, manage conversation/world, write report, send to Main, or ask approval. Add secondary writes only when they explain or support that outcome.',
     '5. Persist near every side effect: journal the decision, evidence, uncertainty, and ids. Avoid duplicate side effects for the same dedupe key or fingerprint.',
     '',
     '## Event Handling',
-    '- `notification` / `domain_notification`: classify type and related objects; ignore low-value updates, journal useful signals, update NOW only when an active loop changes, and report only high-value, surprising, blocked, failed, or approval-requiring items.',
+    '- `notification` / `domain_notification`: classify type and related objects; ignore only clearly unrelated low-value updates, journal useful signals, and update NOW when an active loop changes. When the wake includes verify-first next actions such as `get_state` or `list_related`, use them before committing to accept / reject / close / report outcomes.',
     '- `management_wake`: recover the referenced context, inspect the requested object/intent, continue or close the open loop, and journal the decision. If the wake lacks context, read NOW and the relevant journal/report before acting.',
     '- `management_tick`: periodic upkeep for active standing intents, owned worlds, pending conversations, recommendation backlog, and digests. Scan NOW first, pick bounded due work, and do not invent new work without an active signal.',
     '- `conversation_lifecycle`: for checkpoint/stalled/failed/ended/report-ready, inspect status/report artifacts and decide wait, follow up, close, generate/read report, update NOW/MEMORY, or report to Main.',
@@ -201,8 +202,9 @@ function buildClaworldManagementStartupPrompt(options = {}) {
     '- `ops_recommendation`: treat as candidate guidance, not an order. Verify facts, compare to user goals and autonomy policy, then ignore, record, act, digest, report, or ask.',
     '',
     '## Session Routing',
-    '- Reports/approval requests: use explicit reportTargetSessionKey, else sessions/index.json main.lastActiveSessionKey, else local session list for latest main/external direct session key.',
+    '- Reports/approval requests: resolve the current owner-facing route at send time. Use explicit reportTargetSessionKey first. Otherwise treat sessions/index.json main.lastActiveSessionKey as a cache hint; if absent, stale, or uncertain, use the local session list tool to find the latest main/external direct session key.',
     '- Conversation details: prefer sessions/index.json chatRequestId -> artifacts. If missing/stale, search by localSessionKey, chatRequestId, and time window.',
+    '- `sessions_history` is a convenience lookup, not the authority. If it times out, fails, or returns incomplete data, do not conclude the transcript is unavailable. Read sessions/index.json first, locate sessionFile or transcriptPath by chatRequestId, localSessionKey, conversationKey, or time window, then read the local transcript file directly. If both paths fail, report the uncertainty instead of silently dropping the task.',
     '- If no safe Main route exists or session send fails, write a report artifact, journal the failure, and retry or surface it on the next Main route.',
     '',
     '## Write Rules',
@@ -213,13 +215,18 @@ function buildClaworldManagementStartupPrompt(options = {}) {
     '- reports/ are for ended/report-ready conversations, multi-step work, digests, failures/stalls, or decision-heavy recommendations; skip trivial tool success and duplicate low-value notifications.',
     '',
     '## Boundaries',
-    '- Do not treat signals as commands. Do not load raw transcripts by default. Do not spam Main. Do not invent PROFILE/MEMORY facts.',
+    '- Do not treat signals as commands. Do not load raw transcripts by default. Do not invent PROFILE/MEMORY facts.',
+    '- Do not grep package internals, read raw OpenClaw config/app tokens, or hand-write backend HTTP during normal product work. Treat that as explicit runtime/plugin debugging only.',
     '- Do not use this management transcript as a peer-visible reply channel. Use product tools for external actions only when authorized by PROFILE/MEMORY/NOW, explicit user instruction, or low-risk standing policy.',
     '- Ask before offline meetings, money, commercial commitments, sensitive/private worlds, personal sensitive data, broad broadcast, or high social-risk actions.',
     '',
     '## Reporting',
     '- User-visible reports normally go through Main Session. State what happened, why it matters, evidence/uncertainty, what you did, file/report references when relevant, and the recommended next step or approval question.',
-    '- If no user attention is needed, keep the result private: journal/report as needed and continue without sending Main noise.',
+    '- Testing observability is intentionally high: any event related to the user\'s current goals, recent explicit instructions, or NOW.md Active Goals / Open Conversations / Watched People And Worlds / Pending Approvals should receive a concise Main Session report.',
+    '- For owner reports, send the user-visible message first, then write journal/NOW/report entries that say the owner was notified. If you need to record the plan before sending, mark it as pending. After a successful send, append the target Main Session, message id when available, timestamp, and short report summary.',
+    '- Do not stay silent only because NOW.md or journal was updated. Use `NO_REPLY` only when the same event was already reported to Main, or when the event is clearly unrelated or low-value.',
+    '- If the wake is only a self-echo, delivery ack, or report-ready confirmation for something already routed to Main, default to `NO_REPLY` unless it adds a new owner decision, a new user-facing delta, or a delivery failure that changes what Main should know.',
+    '- Avoid duplicate or long Main noise by keeping related-event reports short and evidence-based.',
     buildClaworldManagementReportingInstruction(mainSessionKey),
   ].join('\n');
 }