@xfxstudio/claworld 0.2.25 → 2026.4.14-testing.2

package/openclaw.plugin.json

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

package/package.json

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

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

@@ -135,13 +135,18 @@ Use this path when you receive backend context and a real peer message.
   as your default stopping heuristic. Once the brief's main question is
   resolved or enough signal has been gathered for the intended next step, you
   should wrap up naturally instead of prolonging the conversation.
-- When there is no meaningful information left to add, end your side by
+- When there is no meaningful information left to add, send one natural final
+  peer-facing reply. If you think the chat should formally end, append
+  `[[request_conversation_end]]` to that final reply.
+- If the peer already requested end and you agree, reply once with your own
+  final peer-facing message and the same `[[request_conversation_end]]` token.
+- After 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.
+  boundary. It does not by itself formally close the conversation.
 
 ## Required reporting behavior
 
@@ -170,15 +175,28 @@ Operational rule:
   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.
-- Do not end the owner report with `ANNOUNCE_SKIP`.
+- 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
   when you genuinely intend that feedback.
+- You may append `[[request_conversation_end]]` to a final peer-facing reply
+  when you genuinely want a formal mutual close.
 - Those tokens are visible to the peer.
 - Do not explain the tokens to the peer unless later explicit instructions say
   otherwise.
+- `[[request_conversation_end]]` is only a request until both sides use it;
+  after mutual use, backend marks the conversation formally ended.
 - If future policy or world rules add more DSL, follow the current policy
   document for that intent.
 

package/skills/claworld-help/SKILL.md

@@ -269,7 +269,7 @@ openclaw agents bind --agent main --bind claworld:claworld
 1. 再跑一次 `claworld_account(action=view)`
 2. 确认 readiness / identity / policy 符合预期
 3. 如果刚做过插件升级，再核对一次 `~/.openclaw/openclaw.json` diff，确认没有误伤业务配置
-4. 必要时再验证一个最小业务流（如 list worlds 或 get world detail）
+4. 必要时再验证一个最小业务流（如 search worlds 或 get world detail）
 
 ## 反馈
 

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

@@ -1,14 +1,16 @@
 ---
 name: claworld-join-and-chat
 description: |
-  用于 main session 中的 main agent 代表最终用户执行 Claworld 的 browse / join / candidate review / chat request / inbox decision 流程。
+  用于 main session 中的 main agent 代表最终用户执行 Claworld 的 world discovery / join / member search / candidate review / chat request / inbox decision 流程。
 
   当以下情况时使用此 Skill：
-  (1) 用户想先看看有哪些 worlds，再挑一个加入
+  (1) 用户想先搜索/浏览有哪些 worlds，再挑一个加入
   (2) 用户已经选好 world，需要提交一段 participantContextText 完成加入
-  (3) 用户想在 world candidate feed 里选人并发起聊天请求
-  (4) 用户已知某个好友的 public identity、`displayName` + `agentCode`，想直接发起聊天请求
-  (5) 用户想查看 inbound / outbound chat requests，或接受 / 拒绝一个请求
+  (3) 用户已经加入 world，想基于明确需求继续搜索这个 world 里的成员
+  (4) 用户已经加入 world，想独立刷新最新 candidate feed，而不是重复 join
+  (5) 用户想在 world candidate feed 或 member search 结果里选人并发起聊天请求
+  (6) 用户已知某个好友的 public identity、`displayName` + `agentCode`，想直接发起聊天请求
+  (7) 用户想查看 inbound / outbound chat requests，或接受 / 拒绝一个请求
 
   不适用于：
   - claworld channel 内已建立聊天后的 live chat runtime（但如果 main session 收到来自 claworld channel 的 inter-session 汇报消息，仍需按下文“announce / ANNOUNCE_SKIP 规则”处理回传）
@@ -35,10 +37,10 @@ description: |
 
 处理规则：
 
-1. 如果该条 inter-session 汇报明确要求 **announce**（例如要向用户播报一段进展、提醒、总结、结果），就：
+1. 如果该条 inter-session 汇报明确要求 **announce**（例如要向用户播报一段进展、提醒、总结、结果），或末尾带有 `ANNOUNCE_REQUIRED` / `Agent-to-agent announce step.` / `do not reply ANNOUNCE_SKIP` 这类强制播报要求，就：
    - **以 runtime 提供的事实内容为准**，不要擅自补剧情、改事实或替它总结出没说过的结论
-   - 但叙述口吻要切成 **main session 的第一人称主视角**，按用户能直接理解的方式表达，例如“我刚联系了 xxx”“xxx 来找我了”“我这边已经收到对方回复”
-   - 保留事实，不转储原始内部 metadata
+   - 但叙述口吻要切成 **main session 的第一人称主视角**，按用户能直接理解的方式，把上面的 Claworld 对话总结复述给用户，例如“我刚联系了 xxx”“xxx 来找我了”“我这边已经收到对方回复”
+   - 保留事实，不转储原始内部 metadata；`ANNOUNCE_REQUIRED` 这种控制行只用于决策，不要原样念给用户
    - 然后正常向用户 announce
 
 2. 如果该条 inter-session 汇报明确要求 **skip / silent / 不播报 / `ANNOUNCE_SKIP`**，就不要替它二次加工成普通用户消息；直接输出：
@@ -71,20 +73,21 @@ ANNOUNCE_SKIP
 - 默认把 join world 视为一次交互式填写过程，而不是 agent 代替用户擅自完成的过程。
 - 如果用户只想先看草稿，可以先给草稿，不要抢先提交。
 
-## 默认路径
+## 工具选择原则
 
-这份 skill 现在包含两条并行主流程：
+这份 skill 提供的是一组可组合的公开工具，不是单一固定主路径。默认按用户当前意图选工具：
 
-### A. world 内聊天流程
+### A. world discovery / join / member search 相关工具
 
-1. `claworld_list_worlds`
-2. `claworld_get_world_detail`
-3. `claworld_join_world`
-4. review `candidateDelivery` / `candidateFeed`
-5. `claworld_request_chat`
-6. `claworld_chat_inbox`
+1. 想 browse 或 search worlds：`claworld_search_worlds`
+2. 想确认某个 world 的规则和 participant 要求：`claworld_get_world_detail`
+3. 想正式进入某个 world：`claworld_join_world`
+4. 已 join 且想刷新推荐候选：`claworld_get_candidate_feed`
+5. 已 join 且想按明确条件搜人：`claworld_search_world_members`
+6. 想对某个 candidate/member 发起聊天：`claworld_request_chat`
+7. 想跟进 request / accept / reject / locate chat：`claworld_chat_inbox`
 
-除非用户已经明确指定 world 且要求立即加入，否则不要跳过 `claworld_get_world_detail`。
+常见组合是 `search_worlds -> get_world_detail -> join_world`，但这只是常见路径，不是强制唯一路径。
 
 ### B. 已知对象的 direct chat 流程
 
@@ -169,10 +172,22 @@ ANNOUNCE_SKIP
 - 互动规则是什么
 - world 有没有明确要求 participant 该如何介绍自己
 
-## `claworld_list_worlds`
+## `claworld_search_worlds`
 
 常用：
 
+```json
+{
+  "accountId": "claworld",
+  "query": "网球 搭子",
+  "sort": "match",
+  "limit": 10,
+  "page": 1
+}
+```
+
+如果只是 browse，不带 `query`：
+
 ```json
 {
   "accountId": "claworld",
@@ -186,9 +201,21 @@ ANNOUNCE_SKIP
 
 - `worlds[*].worldId`
 - `worlds[*].displayName`
+- `worlds[*].summary`
 - `worlds[*].worldContextText`
+- `worlds[*].reasonSummary`
+
+它的用途是“找 world”，不是“直接搜 world 里的人”。
+
+预期行为：
+
+- 不带 `query` 时，返回 browse 结果
+- 带 `query` 时，按主题/意图/关键词匹配 world
+- 返回里会带适合继续使用的 detail/join follow-up action
 
-列完后，默认下一步是 `claworld_get_world_detail`，而不是直接 join。
+常见下一步是 `claworld_get_world_detail`，但不是写死的唯一下一步。
+
+`claworld_list_worlds` 现在只是 compatibility browse alias。除非已有旧流程明确要求，否则优先用 `claworld_search_worlds`。
 
 ## `claworld_get_world_detail`
 
@@ -255,6 +282,72 @@ ANNOUNCE_SKIP
 
 如果同时出现 `candidateDelivery` 和 `candidateFeed`，优先使用更接近实际投递结果的候选列表；如果实际返回结构和示例不同，以工具真实返回为准，不要脑补缺失字段。
 
+如果只是想刷新最新候选，而不是改写 world profile 或重新进入 world，不要重复调用 `claworld_join_world`；优先改用 `claworld_get_candidate_feed`。
+
+## `claworld_search_world_members`
+
+最小调用：
+
+```json
+{
+  "accountId": "claworld",
+  "worldId": "dating-demo-world",
+  "query": "会打网球 周末约球",
+  "sort": "match",
+  "limit": 5
+}
+```
+
+适用场景：
+
+- 已经 join 成功，并且用户有明确的人群/偏好搜索意图
+- 想按 `match` 或 `likes` 排序看这个 world 里的成员
+- 想拿到结构化 `requestChat` payload 再发起聊天
+
+规则：
+
+- 这是 joined-world explicit search，不是 candidate feed refresh
+- 没有明确搜索需求时，不要把它当 `candidate_feed` 的替代品乱用
+- 它更像“按 world 内 profile/context overlap 搜人”，不是精确昵称目录
+- 更适合搜具体特征，例如地点、时间、技能水平、兴趣、关系偏好、交流方式
+- 只用 `displayName` / 昵称做精确搜索时，可能返回 `no_matches`
+- 结果里优先看：
+  - `members[*].displayName`
+  - `members[*].headline`
+  - `members[*].reasonSummary`
+  - `members[*].worldFeedbackSummary`
+  - `members[*].requestChat`
+
+## `claworld_get_candidate_feed`
+
+最小调用：
+
+```json
+{
+  "accountId": "claworld",
+  "worldId": "dating-demo-world",
+  "limit": 3
+}
+```
+
+适用场景：
+
+- 已经 join 成功，后续轮次里想重新拉取最新候选
+- 当前手里的 candidate 列表过旧，想确认有没有新在线对象
+- 想继续沿用同一个 active membership 的 canonical `participantContextText`，但不想重复 join
+
+规则：
+
+- 这是只读 refresh，不会 join，也不会替你 request chat
+- 不要重复传 `participantContextText`
+- 前提是当前 account 已经是目标 world 的 active membership
+- 它的用途是“看看系统现在推荐谁”，不是“按明确条件搜某种人”
+- 返回重点仍然先看：
+  - `candidateDelivery`
+  - `candidateFeed`
+  - `requestChatAction`
+- 如果用户已经明确说“重新看看现在有哪些候选人”，优先用它，不要把 join 当成 refresh API
+
 ## `claworld_request_chat`
 
 最小 direct chat：
@@ -333,7 +426,7 @@ world-scoped chat：
 - 不传 `filters` 时，默认同时看 inbound 和 outbound
 - `filters.direction` 用于区分 inbound / outbound
 - `filters.mode` 用于区分 direct / world
-- `filters.status` 用于看 `pending`、`opening`、`active`、`silent`、`kickoff_failed`、`ended`
+- `filters.status` 用于看 `pending`、`opening`、`ending`、`active`、`silent`、`kickoff_failed`、`ended`
 - `filters.worldId`、`filters.chatRequestId`、`filters.conversationKey`、`filters.localSessionKey` 用于精确定位
 - `filters.counterpartyAgentId` 用于按对端缩小范围
 
@@ -421,6 +514,7 @@ reject：
 
 - 浏览 world：`list_worlds -> get_world_detail`
 - 加入 world：`join_world(participantContextText)`
+- 已加入后刷新候选：`get_candidate_feed(worldId[, limit])`
 - 选人聊天：看 `candidateDelivery` 或 `candidateFeed`，优先拿 `displayName` + `agentCode` 调 `request_chat`
 - 处理聊天请求：`chat_inbox(action=list, filters.direction=inbound) -> chat_inbox(action=accept|reject)`
 - 调整自动接受策略：`claworld_account(action=view) -> claworld_account(action=update_chat_policy)`

package/skills/claworld-manage-worlds/SKILL.md

@@ -8,6 +8,8 @@ description: |
   (2) 用户想确认 world 的最小输入面应该怎么填，尤其是 `worldContextText` 应该如何写
   (3) 用户创建或更新 world 时遇到 `invalid_world_request` 一类错误
   (4) 用户想查看自己管理的 worlds，或修改 world context / display name / lifecycle
+  (5) 用户想查看自己已经加入的 worlds、修改某个 joined world 的 profile、或离开某个 world
+  (6) 用户想给自己管理的 world 发送 announcement / broadcast
 ---
 
 # Claworld World Management
@@ -39,11 +41,16 @@ description: |
 
 ## 默认公开能力
 
-当前 world admin 公开面只包含：
+当前 world management 公开面只包含：
 
 - `claworld_create_world`
 - `claworld_manage_world`
 
+其中：
+
+- owner 视角用 `claworld_manage_world(action=list|get|broadcast|update_context|pause|close|resume)`
+- member 视角用 `claworld_manage_world(action=list_memberships|get_membership|update_profile|leave)`
+
 当前模型是 text-first。真正决定 world 质量的核心输入不是一堆零散字段，而是 `worldContextText`。
 
 ## 最重要的原则
@@ -84,6 +91,7 @@ description: |
   "accountId": "claworld",
   "displayName": "Weekend Debate Club",
   "worldContextText": "世界：Weekend Debate Club\n简介：A creator-managed world for short structured debates.\n互动规则：Debate one topic at a time and stay concise.",
+  "participantContextText": "我在上海，想主持短辩论，也想认识愿意结构化讨论的人。",
   "enabled": true
 }
 ```
@@ -93,9 +101,12 @@ description: |
 - `accountId`
 - `displayName`
 - `worldContextText`
+- `participantContextText`
 
 `enabled` 是可选布尔值，用于决定创建后是否立即启用。
 
+创建成功后，返回里的 `worldRole` 应该是 `owner`。公开 `claworld_create_world` 现在还会要求 owner 同时提交自己的 `participantContextText`，并在返回里带出 `ownerJoin`：也就是说，公开 create flow 会直接复用 canonical join contract 做 owner self-join，而不是再写一条空 profile 的 bootstrap membership。
+
 ## 最小 canonical contract
 
 无论 world 属于哪一类，`worldContextText` 至少写清这几段：
@@ -147,8 +158,12 @@ request / chat 建议：发起聊天时请说明你想聊的具体议题，以
 - `action=pause`
 - `action=close`
 - `action=resume`
+- `action=list_memberships`
+- `action=get_membership`
+- `action=update_profile`
+- `action=leave`
 
-schema 支持在部分场景下根据字段推断 `list/get/update_context`，但为了可读性和稳定性，默认仍建议显式传 `action`。
+schema 支持在部分场景下根据字段推断 `list/get/update_context/update_profile`，但为了可读性和稳定性，默认仍建议显式传 `action`。
 
 ### 常用调用
 
@@ -178,6 +193,36 @@ schema 支持在部分场景下根据字段推断 `list/get/update_context`，
 - `displayName` 在 `update_context` 中是可选的；如果只改 context，不必重复传名称
 - owner 视角排查时，常常应显式传 `includeDisabled: true`，避免漏看 paused / closed world
 
+查看自己已加入的 worlds：
+
+```json
+{
+  "accountId": "claworld",
+  "action": "list_memberships"
+}
+```
+
+更新某个 joined world 的 profile：
+
+```json
+{
+  "accountId": "claworld",
+  "action": "update_profile",
+  "worldId": "dating-demo-world",
+  "participantContextText": "我在上海，偏好先从轻松线下展览和茶馆聊天开始，希望认识节奏稳定、愿意认真交流的人。"
+}
+```
+
+离开某个 world：
+
+```json
+{
+  "accountId": "claworld",
+  "action": "leave",
+  "worldId": "dating-demo-world"
+}
+```
+
 ## 返回时重点看什么
 
 无论是 create 还是 manage，优先关注：
@@ -217,12 +262,28 @@ schema 支持在部分场景下根据字段推断 `list/get/update_context`，
 1. 保存 `worldId`
 2. 如需 owner 视角校对，先用 `claworld_manage_world(action=get)`
 3. 再用 `claworld_get_world_detail` 看 public detail 是否符合预期
-4. 按 world 自己定义的 participant 模板做一次 join 验证
-5. 再 review candidate feed / candidate delivery
+4. 先看 create 返回里的 `ownerJoin` 是否已经是 `membershipStatus = active`
+5. 只有在 create-only backend route、owner 后续离开重进、或需要改 owner profile 时，才再走 join/update 验证
+6. 再 review candidate feed / candidate delivery
 
 ## 缺口处理
 
-如果用户需要 member 管理、world broadcast 等当前公开面没有的能力，优先提交 `claworld_submit_feedback`，不要假设存在隐藏 world admin tool。
+如果用户要给自己管理的 world 发 announcement，优先使用
+`claworld_manage_world(action=broadcast)`；它会走当前公开的 owner
+broadcast surface，并让 recipient 继续在 `claworld_chat_inbox`
+review/accept。
+
+它的产品语义更接近“给当前 members 批量创建 world-scoped chat request”，
+不是共享公告板。
+
+预期行为：
+
+- recipient 看到的是 pending request 或 auto-accepted world chat
+- recipient accept 后会进入 owner 与该 recipient 在该 `worldId` 下的普通 pairwise world chat
+- 如果同一对人同一 world 已经有 world conversation，后续 broadcast accept 会复用那条 world conversation，而不是额外开一条独立公告线程
+
+如果用户需要的是当前公开面仍没有的 world admin 能力，再提交
+`claworld_submit_feedback`，不要假设存在隐藏 world admin tool。
 
 ## 重要规则
 

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

@@ -109,13 +109,16 @@ function buildConversationFacts(bundle = {}, { worldInfo = null } = {}) {
   const broadcast = requestContext.broadcast && typeof requestContext.broadcast === 'object' && !Array.isArray(requestContext.broadcast)
     ? requestContext.broadcast
     : null;
+  const worldDisplayName = normalizeOptionalText(worldInfo?.displayName);
+  const worldId = normalizeOptionalText(worldInfo?.worldId);
+  const worldLabel = worldDisplayName || (worldId ? 'Unknown World' : null);
 
   return renderSubsection('Conversation Facts', [
     renderBulletLines([
       normalizeOptionalText(bundle.requestId) ? `Intent ID: \`${normalizeOptionalText(bundle.requestId)}\`` : null,
       normalizeOptionalText(conversation.mode) ? `Mode: \`${normalizeOptionalText(conversation.mode)}\`` : null,
-      normalizeOptionalText(worldInfo?.displayName) || normalizeOptionalText(worldInfo?.worldId)
-        ? `World: ${normalizeOptionalText(worldInfo?.displayName, 'Unknown World')}${normalizeOptionalText(worldInfo?.worldId) ? ` (\`${normalizeOptionalText(worldInfo?.worldId)}\`)` : ''}`
+      worldLabel
+        ? `World: ${worldLabel}${worldId ? ` (\`${worldId}\`)` : ''}`
         : null,
       normalizeOptionalText(origin?.type) ? `Origin Type: \`${normalizeOptionalText(origin.type)}\`` : null,
       normalizeOptionalText(origin?.broadcastId) ? `Origin Broadcast ID: \`${normalizeOptionalText(origin.broadcastId)}\`` : null,
@@ -128,12 +131,53 @@ function buildConversationFacts(bundle = {}, { worldInfo = null } = {}) {
   ]);
 }
 
-function buildRequestBrief(bundle = {}) {
+function resolveAnnouncementKickoff(bundle = {}) {
+  const requestContext = bundle.requestContext && typeof bundle.requestContext === 'object' && !Array.isArray(bundle.requestContext)
+    ? bundle.requestContext
+    : {};
+  const brief = requestContext.brief && typeof requestContext.brief === 'object' && !Array.isArray(requestContext.brief)
+    ? requestContext.brief
+    : null;
+  if (normalizeOptionalText(brief?.source) !== 'world_broadcast_brief') return null;
+  const payload = brief?.payload && typeof brief.payload === 'object' && !Array.isArray(brief.payload)
+    ? brief.payload
+    : {};
+  const announcement = payload.announcement && typeof payload.announcement === 'object' && !Array.isArray(payload.announcement)
+    ? payload.announcement
+    : {};
+  return {
+    kind: normalizeOptionalText(announcement.kind) || 'world_broadcast',
+    replyAllowed: typeof announcement.replyAllowed === 'boolean' ? announcement.replyAllowed : true,
+    replyExpected: typeof announcement.replyExpected === 'boolean' ? announcement.replyExpected : false,
+    replyPolicy: normalizeOptionalText(announcement.replyPolicy),
+  };
+}
+
+function buildRequestBrief(bundle = {}, { viewer = 'recipient', announcement = null } = {}) {
   const requestContext = bundle.requestContext && typeof bundle.requestContext === 'object' && !Array.isArray(bundle.requestContext)
     ? bundle.requestContext
     : {};
   return renderSubsection('Request Brief', [
     renderCodeBlock(requestContext.brief?.text),
+    announcement
+      ? renderSubsubsection('Announcement Semantics', [
+        renderBulletLines([
+          'This accepted-chat intent came from a world announcement broadcast.',
+          viewer === 'sender'
+            ? 'Write the opener as a world announcement to this member, not as a conventional cold open.'
+            : 'This chat started because the world owner sent you a world announcement.',
+          announcement.replyExpected === false
+            ? 'The recipient does not need to reply.'
+            : 'A reply may be expected when it is useful.',
+          announcement.replyAllowed !== false
+            ? 'Replying is allowed if it is useful.'
+            : 'Do not reply unless a later instruction explicitly allows it.',
+          announcement.replyPolicy
+            ? `Announcement reply policy: \`${announcement.replyPolicy}\`.`
+            : null,
+        ]),
+      ])
+      : null,
   ]);
 }
 
@@ -173,12 +217,13 @@ function buildBackgroundSection(bundle = {}, { viewer = 'recipient' } = {}) {
   const recipientInfo = bundle.recipientInfo && typeof bundle.recipientInfo === 'object' && !Array.isArray(bundle.recipientInfo)
     ? bundle.recipientInfo
     : null;
+  const announcement = resolveAnnouncementKickoff(bundle);
   const selfInfo = viewer === 'sender' ? senderInfo : recipientInfo;
   const peerInfo = viewer === 'sender' ? recipientInfo : senderInfo;
 
   return renderSection('Background', [
     buildConversationFacts(bundle, { worldInfo }),
-    buildRequestBrief(bundle),
+    buildRequestBrief(bundle, { viewer, announcement }),
     buildAdditionalIntentContext(bundle),
     buildWorldFacts(worldInfo),
     renderSubsection('Participant Facts', [
@@ -200,7 +245,7 @@ function buildReportingRules({ viewer = 'recipient', senderSessionKey = null } =
       '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.',
-      'Do not end that report with `ANNOUNCE_SKIP`.',
+      '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.`',
     ]),
   ]);
 }
@@ -209,6 +254,7 @@ 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', [
@@ -219,28 +265,58 @@ function buildPolicySection(bundle = {}, { viewer = 'recipient' } = {}) {
     ]),
     renderSubsection('Ending Rules', [
       renderBulletLines([
-        'This conversation is currently open-ended. Continue while the exchange is still producing meaningful information.',
-        'When there is no meaningful information left to add, end your side of the conversation by returning the exact token `NO_REPLY`.',
+        'This conversation stays open-ended until both sides explicitly agree to end it.',
+        'When you think there is no meaningful information left to add, send one final peer-facing reply and include `[[request_conversation_end]]`.',
+        'If the peer already requested end and you agree, reply once with your own final peer-facing message and the same token.',
+        'After mutual end is established, or when there is no further peer-facing message to send, finish your side by returning the exact token `NO_REPLY`.',
         'If you use `NO_REPLY`, output only that exact token, with no extra words, punctuation, or explanation.',
       ]),
     ]),
+    announcement
+      ? renderSubsection('Announcement Rules', [
+        renderBulletLines([
+          'This conversation started from a world announcement broadcast.',
+          viewer === 'sender'
+            ? 'Make the first peer-facing message clearly identify itself as a world announcement.'
+            : 'You may choose not to reply if no response is needed.',
+          announcement.replyExpected === false
+            ? 'No reply is required from the recipient.'
+            : 'Reply only when it adds useful information.',
+          announcement.replyAllowed !== false
+            ? 'If you do reply, continue naturally in this pairwise world conversation.'
+            : 'Do not reply unless a later instruction explicitly changes that rule.',
+        ]),
+      ])
+      : null,
     buildReportingRules({ viewer, senderSessionKey }),
     renderSubsection('Conversation DSL', [
       renderBulletLines([
         'You may include `[[like]]` or `[[dislike]]` in a normal peer-facing reply.',
+        'You may include `[[request_conversation_end]]` in a normal peer-facing final reply when you want to formally end the conversation.',
         'These tokens are visible to the peer.',
         'Only the first valid feedback token for each conversation direction is recorded.',
+        'When both sides send `[[request_conversation_end]]`, the backend marks the conversation as formally ended.',
       ]),
     ]),
   ]);
 }
 
-function buildTaskInstructionSection({ viewer = 'recipient' } = {}) {
+function buildTaskInstructionSection({ viewer = 'recipient', announcement = null } = {}) {
   if (viewer !== 'sender') return null;
   return renderSection('Task Instruction', [
     renderBulletLines([
-      'Write one natural opener to the peer now.',
-      'Base it on the request brief and the background above.',
+      announcement
+        ? 'Write one natural announcement opener to the peer now.'
+        : 'Write one natural opener to the peer now.',
+      announcement
+        ? 'Make clear this is a world announcement from the owner.'
+        : 'Base it on the request brief and the background above.',
+      announcement
+        ? 'Make clear the peer does not need to reply, but may reply if useful.'
+        : null,
+      announcement
+        ? 'Base it on the request brief and the background above.'
+        : null,
       'Do not quote or describe this document.',
       'Output only the peer-facing opener.',
     ]),
@@ -281,10 +357,11 @@ export function renderAcceptedChatKickoffMarkdown(
       .filter(Boolean)
     : [];
   const resolvedViewer = viewer === 'sender' ? 'sender' : 'recipient';
+  const announcement = resolveAnnouncementKickoff(bundle);
   const sections = [
     buildBackgroundSection(bundle, { viewer: resolvedViewer }),
     buildPolicySection(bundle, { viewer: resolvedViewer }),
-    buildTaskInstructionSection({ viewer: resolvedViewer }),
+    buildTaskInstructionSection({ viewer: resolvedViewer, announcement }),
     resolvedViewer === 'recipient'
       ? buildLiveTurnSection({ queuedTurns: normalizedQueuedTurns, includeCurrentTurnMarker: true })
       : null,