@clawling/clawchat-plugin-openclaw 2026.10.7-1 → 2026.10.7-2

package/dist/src/runtime.js

@@ -859,6 +859,10 @@ export async function startOpenclawClawlingGateway(params) {
     // `sendOwnerSkillMessage` below) — both live in this same function closure, so
     // the forward reference here just resolves to the fresh value at call time.
     let livewareSampleNotify = async () => false;
+    // The supervisor this gateway call shares (new or adopted). The abort cleanup
+    // below awaits its stop() so the host's channel stop (which waits on this
+    // task) does not return while liveware children are still being killed.
+    let livewareSampleForShutdown = null;
     if (store) {
         const stateDirForSample = runtime.state?.resolveStateDir?.();
         const livewareSampleDeps = {
@@ -901,6 +905,7 @@ export async function startOpenclawClawlingGateway(params) {
         livewareSampleSupervisors.set(abortSignal, supervisorsForSignal);
         const supervisorKey = `openclaw:${accountId}`;
         const runningSupervisor = supervisorsForSignal.get(supervisorKey);
+        livewareSampleForShutdown = runningSupervisor ?? null;
         if (runningSupervisor) {
             // A gateway re-entry (refresh/backoff reconnect), not a fresh channel start:
             // hand the live supervisor this closure's token + REST client + notify path
@@ -910,9 +915,12 @@ export async function startOpenclawClawlingGateway(params) {
         }
         else {
             const livewareSampleSupervisor = new LivewareSampleSupervisor(livewareSampleDeps);
+            livewareSampleForShutdown = livewareSampleSupervisor;
             supervisorsForSignal.set(supervisorKey, livewareSampleSupervisor);
             abortSignal.addEventListener("abort", () => {
-                livewareSampleSupervisor.stop();
+                // Starts the SIGTERM → SIGKILL teardown at once; the gateway's own
+                // abort cleanup awaits the same (idempotent) stop() promise.
+                void livewareSampleSupervisor.stop();
                 if (supervisorsForSignal.get(supervisorKey) === livewareSampleSupervisor) {
                     supervisorsForSignal.delete(supervisorKey);
                 }
@@ -1188,6 +1196,25 @@ export async function startOpenclawClawlingGateway(params) {
     const persistOwnerProfile = upsertOwnerProfile
         ? makeOwnerProfilePersister({ upsertOwnerProfile }, { accountId })
         : undefined;
+    // The owner_profile row is where owner-language copy reads its locale
+    // (framework errors, greetings, liveware intros). It was only refreshed on
+    // owner metadata pulls, so an owner who switched app language kept getting
+    // the old one. friend.profile_updated also reaches the agent when the
+    // owner edits their profile; refetch just the owner row then.
+    const refreshOwnerProfileOnUpdate = (entityId) => {
+        const subject = typeof entityId === "string" ? entityId.trim() : "";
+        if (!persistOwnerProfile || !subject || subject !== account.ownerUserId)
+            return;
+        void (async () => {
+            try {
+                const owner = await getConversationApiClient().getAgentOwner();
+                persistOwnerProfile(owner);
+            }
+            catch (err) {
+                log?.error?.(`[${accountId}] clawchat-plugin-openclaw owner profile refresh failed source=friend.profile_updated: ${err instanceof Error ? err.message : String(err)}`);
+            }
+        })();
+    };
     const refreshAgentBehavior = async (options) => {
         try {
             await pullOwnerMetadata({
@@ -2305,6 +2332,9 @@ export async function startOpenclawClawlingGateway(params) {
                 if (type === "friend.added") {
                     scheduleFriendGreeting(payload);
                 }
+                if (type === "friend.profile_updated") {
+                    refreshOwnerProfileOnUpdate(payload?.entity_id);
+                }
             }
         }
     });
@@ -2409,6 +2439,8 @@ export async function startOpenclawClawlingGateway(params) {
                         ? groupFile.metadata.group_owner_nickname ?? metadata?.nickname ?? userId
                         : metadata?.nickname ?? userId;
             const profileType = metadata?.profile_type ?? (userId === account.userId ? "agent" : "user");
+            if (name !== userId)
+                knownNicknames.set(userId, name);
             participants.push({ id: userId, name, profileType, isAgentOwner, isGroupOwner });
         }
         return participants;
@@ -2444,6 +2476,7 @@ export async function startOpenclawClawlingGateway(params) {
             basePrompt: turn.peer.kind === "group" ? getClawChatGroupPrompt() : getClawChatUserPrompt(),
             ...promptMetadata,
             ownerIdFallback: account.ownerUserId,
+            currentAgentIdFallback: account.userId,
             groupParticipants,
             turn: {
                 chatType: promptChatType,
@@ -2463,9 +2496,76 @@ export async function startOpenclawClawlingGateway(params) {
             },
         });
     };
+    // Group frames often carry the sender's id as nick_name. Prefer the nickname
+    // already cached in ClawChat memory (owner.md for the owner and this agent,
+    // users/<id>.md for everyone else, the group's group_owner_nickname for its
+    // owner); keep the id when nothing is cached.
+    const cachedNicknameFor = async (memoryRoot, userId) => {
+        try {
+            if (userId === account.ownerUserId || userId === account.userId) {
+                const ownerFile = await readClawChatMemoryFile(memoryRoot, { targetType: "owner", targetId: "owner" });
+                const nickname = userId === account.userId
+                    ? ownerFile.metadata.agent_nickname
+                    : ownerFile.metadata.agent_owner_nickname;
+                if (nickname)
+                    return nickname;
+            }
+            const userFile = await readClawChatMemoryFile(memoryRoot, { targetType: "user", targetId: userId });
+            return userFile.exists && userFile.metadata.nickname ? userFile.metadata.nickname : null;
+        }
+        catch {
+            return null;
+        }
+    };
+    // Nicknames seen while building group prompts, so ingest can label a
+    // coalesced batch's transcript ("Alice:" rather than "usr_…:") without
+    // touching disk.
+    const knownNicknames = new Map();
+    const withCachedGroupSenderNames = async (turn, memoryRoot) => {
+        if (turn.peer.kind !== "group" || !memoryRoot)
+            return turn;
+        const isBareId = (name, id) => !name || name === id;
+        const cache = new Map();
+        let groupOwner = null;
+        const lookup = async (userId) => {
+            if (!cache.has(userId)) {
+                let nickname = await cachedNicknameFor(memoryRoot, userId);
+                if (!nickname) {
+                    if (!groupOwner) {
+                        try {
+                            const groupFile = await readClawChatMemoryFile(memoryRoot, { targetType: "group", targetId: turn.peer.id });
+                            groupOwner = { id: groupFile.metadata.group_owner_id, nickname: groupFile.metadata.group_owner_nickname };
+                        }
+                        catch {
+                            groupOwner = {};
+                        }
+                    }
+                    if (groupOwner.id === userId && groupOwner.nickname)
+                        nickname = groupOwner.nickname;
+                }
+                cache.set(userId, nickname);
+                if (nickname)
+                    knownNicknames.set(userId, nickname);
+            }
+            return cache.get(userId) ?? null;
+        };
+        const senderNickName = isBareId(turn.senderNickName, turn.senderId)
+            ? (await lookup(turn.senderId)) ?? turn.senderNickName
+            : turn.senderNickName;
+        const groupMessages = turn.groupMessages
+            ? await Promise.all(turn.groupMessages.map(async (message) => isBareId(message.senderName, message.senderId)
+                ? { ...message, senderName: (await lookup(message.senderId)) ?? message.senderName }
+                : message))
+            : turn.groupMessages;
+        return { ...turn, senderNickName, ...(groupMessages ? { groupMessages } : {}) };
+    };
     const resolveSenderNickNameForTurn = (turn) => {
         if (turn.senderNickName && turn.senderNickName !== turn.senderId)
             return turn.senderNickName;
+        // Synchronous on purpose: an await here would reorder same-group frames.
+        const known = turn.peer.kind === "group" ? knownNicknames.get(turn.senderId) : undefined;
+        if (known)
+            return known;
         return turn.senderNickName || turn.senderId;
     };
     const resolveSenderBatchIdentityForTurn = (turn) => {
@@ -2480,7 +2580,9 @@ export async function startOpenclawClawlingGateway(params) {
             senderProfileType: turn.senderProfileType ??
                 (senderRelation === "self_agent" || senderRelation === "peer_agent" ? "agent" : "user"),
             senderIsOwner: senderRelation === "owner",
-            senderIsGroupOwner: turn.senderIsGroupOwner ?? false,
+            // Left undefined when the frame does not say, so the prompt falls back
+            // to the group metadata's group_owner_id instead of a forced false.
+            ...(turn.senderIsGroupOwner !== undefined ? { senderIsGroupOwner: turn.senderIsGroupOwner } : {}),
         };
     };
     const claimInboundTurn = (turn) => {
@@ -2550,6 +2652,7 @@ export async function startOpenclawClawlingGateway(params) {
         catch (err) {
             log?.error?.(`[${accountId}] clawchat-plugin-openclaw message metadata refresh failed: ${err instanceof Error ? err.message : String(err)}`);
         }
+        turn = await withCachedGroupSenderNames(turn, memoryRoot);
         const conversationTarget = `${CHANNEL_ID}:${formatConversationSubject(turn.peer)}`;
         const turnPrompt = await buildPromptForTurn(turn, memoryRoot);
         const senderIsOwner = turn.senderIsOwner === true || turn.senderId === account.ownerUserId;
@@ -2680,6 +2783,7 @@ export async function startOpenclawClawlingGateway(params) {
                 runtime,
                 account,
                 client,
+                resolveOwnerLocale: () => store?.getOwnerProfile?.({ platform: "openclaw", accountId })?.locale ?? null,
                 target: { chatId: turn.peer.id, chatType: turn.peer.kind },
                 ...(replyCtx ? { replyCtx } : {}),
                 inboundMessageId: turn.messageId,
@@ -3270,6 +3374,16 @@ export async function startOpenclawClawlingGateway(params) {
             closeReason: "client close",
         });
         client.close();
+        if (livewareSampleForShutdown) {
+            // SIGTERM, then SIGKILL after KILL_GRACE_MS (3 s): inside the host's
+            // 5 s wait for this task, so a stuck child no longer outlives the stop.
+            try {
+                await livewareSampleForShutdown.stop();
+            }
+            catch (err) {
+                log?.error?.(`[${accountId}] clawchat-plugin-openclaw liveware-sample stop failed: ${err instanceof Error ? err.message : String(err)}`);
+            }
+        }
         setStatus({
             ...getStatus(),
             connected: false,

package/dist/src/skill-update.js

@@ -66,7 +66,7 @@ export const OFFICIAL_SKILLS_BASE = "https://raw.githubusercontent.com/clawling/
  * in the install-cli repo, bump this constant, ship it. `liveware-sample.ts`
  * imports the same ref, so the `livewares` tree at that tag is pinned too.
  */
-export const DEFAULT_SKILLS_REF = "skills-v1.16.0";
+export const DEFAULT_SKILLS_REF = "skills-v1.17.0";
 /** Refuse to treat an absurdly large response as a skill file (defence in depth). */
 export const MAX_SKILL_BYTES = 256 * 1024;
 /** This adapter's host target inside `skills/manifest.json`. */

package/dist/src/tools-schema.js

@@ -205,7 +205,7 @@ export const ClawchatCreateMomentSchema = Type.Object({
         description: "Moment text. At least one of text or images is required.",
     })),
     images: Type.Optional(Type.Array(Type.String({
-        description: "Image URL for the moment. Upload local files first; do not pass local paths.",
+        description: "An http(s) image URL, or an absolute local image path (the tool uploads it and uses the hosted URL).",
     }))),
 });
 export const ClawchatDeleteMomentSchema = Type.Object({

package/dist/src/tools.js

@@ -28,6 +28,15 @@ function extractRequestId(err) {
     }
     return undefined;
 }
+/**
+ * What the agent must do with the later `permission_result` receipt
+ * (agent-protocol §2.8): on approval the SERVER executes the gated call, so a
+ * second call would duplicate it or raise a fresh card. Only `approved_retry`
+ * (reads, which are never replayed) asks for exactly one more call.
+ */
+const PERMISSION_RECEIPT_RULE = "When the result arrives: outcome \"approved\" (or \"auto_allowed\") means the server has already done it for you — do not call this tool again; " +
+    "only outcome \"approved_retry\" means call this same tool once more with the same arguments. " +
+    "Anything the server produced (a new id, a code, read data) comes in that message's Result line.";
 function permissionGateResult(err) {
     const code = err.meta?.code;
     const requestId = extractRequestId(err);
@@ -38,7 +47,8 @@ function permissionGateResult(err) {
             "This operation requires the owner's approval and has been submitted for review" +
                 (requestId ? ` (request_id=${requestId})` : "") +
                 ". It has NOT failed. Do not retry — the result will arrive later as a normal " +
-                "chat message; wait for it instead of calling this tool again.";
+                "chat message; wait for it instead of calling this tool again. " +
+                PERMISSION_RECEIPT_RULE;
         status = "pending";
     }
     else {
@@ -120,6 +130,46 @@ function inferMimeFromPath(filePath) {
     const ext = path.extname(filePath).toLowerCase();
     return MIME_BY_EXT[ext] ?? "application/octet-stream";
 }
+/**
+ * Classify `clawchat_create_moment` image entries: http(s) URLs pass through;
+ * an existing absolute local regular file (≤ 20MB) is marked for upload; any
+ * other value is a validation error naming the offending index.
+ */
+function planMomentImages(images) {
+    const entries = [];
+    for (const [i, raw] of images.entries()) {
+        const where = `clawchat-plugin-openclaw: images[${i}]`;
+        const value = typeof raw === "string" ? raw.trim() : "";
+        if (!value) {
+            return { ok: false, message: `${where} must be an http(s) image URL or an absolute local image path` };
+        }
+        if (/^https?:\/\/\S+$/i.test(value)) {
+            entries.push({ kind: "url", url: value });
+            continue;
+        }
+        if (!path.isAbsolute(value)) {
+            return {
+                ok: false,
+                message: `${where} (${JSON.stringify(value)}) is neither an http(s) URL nor an absolute local file path; no moment was created`,
+            };
+        }
+        let stat;
+        try {
+            stat = fs.statSync(value);
+        }
+        catch {
+            return { ok: false, message: `${where}: local file ${value} does not exist; no moment was created` };
+        }
+        if (!stat.isFile()) {
+            return { ok: false, message: `${where}: ${value} is not a regular file; no moment was created` };
+        }
+        if (stat.size > MAX_UPLOAD_BYTES) {
+            return { ok: false, message: `${where}: ${value} is too large (${stat.size} bytes; max 20MB)` };
+        }
+        entries.push({ kind: "local", path: value });
+    }
+    return { ok: true, entries };
+}
 function validateMentionMessageParams(params) {
     if (!params || typeof params !== "object") {
         return { ok: false, message: "clawchat-plugin-openclaw: params are required" };
@@ -285,6 +335,7 @@ export function registerOpenclawClawlingTools(api, options = {}) {
             ok: true,
             client: createOpenclawClawlingApiClient({
                 baseUrl: acct.baseUrl,
+                mediaBaseUrl: acct.mediaBaseUrl,
                 token: acct.token,
                 userId: acct.userId,
             }),
@@ -329,8 +380,16 @@ export function registerOpenclawClawlingTools(api, options = {}) {
                             ? rawData
                             : {};
                         const outcome = mapGateOutcome(code, gateData);
-                        if (outcome !== null)
-                            return jsonResponse(outcome);
+                        if (outcome !== null) {
+                            // `next_step` is added here, not in mapGateOutcome: that mapping
+                            // is pinned byte-for-byte against the Hermes parity fixtures.
+                            return jsonResponse(outcome.status === "pending_owner_approval"
+                                ? {
+                                    ...outcome,
+                                    next_step: "Waiting for the owner's approval; do not call this tool again now. " + PERMISSION_RECEIPT_RULE,
+                                }
+                                : outcome);
+                        }
                     }
                     return apiError(err);
                 }
@@ -1100,7 +1159,7 @@ export function registerOpenclawClawlingTools(api, options = {}) {
             label: "Create ClawChat Moment",
             description: toolDescription("Create a new ClawChat moment/dynamic for the configured ClawChat account. " +
                 "TRIGGER - invoke when the user asks to publish, post, or send a ClawChat moment/dynamic, such as \"post a ClawChat moment saying ...\", \"publish a dynamic ...\", or \"send a friend moment ...\". " +
-                "At least one of text or images must be present. For local image files, upload first with the appropriate media upload tool and pass the returned URLs in images; do not pass local file paths as images."),
+                "At least one of text or images must be present. Each images entry is either an http(s) image URL (used as-is) or an absolute local image path (max 20MB) — for a local path this tool uploads it to ClawChat media itself and uses the hosted URL, so no separate upload step is needed. Any other value (relative path, file:// or data: URI, missing file) is rejected and no moment is created."),
             parameters: ClawchatCreateMomentSchema,
             async execute(_callId, params) {
                 return await recordClawchatToolCall(accountId, "clawchat_create_moment", params, async () => {
@@ -1110,10 +1169,33 @@ export function registerOpenclawClawlingTools(api, options = {}) {
                     if (!text && (!images || images.length === 0)) {
                         return validationError("clawchat-plugin-openclaw: at least one of text or images is required");
                     }
-                    return await withGatedClient(accountId, (c) => c.createMoment({
-                        ...(text !== undefined ? { text } : {}),
-                        ...(images !== undefined ? { images } : {}),
-                    }));
+                    // Validate every entry before touching the network, so a bad value
+                    // never leaves a half-uploaded batch or a moment with a broken image.
+                    const plan = images !== undefined ? planMomentImages(images) : { ok: true, entries: [] };
+                    if (!plan.ok)
+                        return validationError(plan.message);
+                    return await withGatedClient(accountId, async (c) => {
+                        const resolved = [];
+                        for (const entry of plan.entries) {
+                            if (entry.kind === "url") {
+                                resolved.push(entry.url);
+                                continue;
+                            }
+                            const uploaded = await c.uploadMedia({
+                                buffer: fs.readFileSync(entry.path),
+                                filename: path.basename(entry.path),
+                                mime: inferMimeFromPath(entry.path),
+                            });
+                            if (uploaded.kind !== "image") {
+                                throw new Error(`clawchat-plugin-openclaw: ${entry.path} is not an image (media service classified it as ${uploaded.kind}); no moment was created`);
+                            }
+                            resolved.push(uploaded.url);
+                        }
+                        return await c.createMoment({
+                            ...(text !== undefined ? { text } : {}),
+                            ...(images !== undefined ? { images: resolved } : {}),
+                        });
+                    });
                 });
             },
         };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@clawling/clawchat-plugin-openclaw",
-  "version": "2026.10.7-1",
+  "version": "2026.10.7-2",
   "description": "OpenClaw ClawChat channel plugin",
   "license": "MIT",
   "author": "CLAWLING PTE. LTD.",
@@ -42,7 +42,8 @@
     "build": "tsc -p tsconfig.build.json",
     "test": "vitest",
     "dev:openclaw-source": "test -d tmp/openclaw || git clone --depth=1 https://github.com/openclaw/openclaw.git tmp/openclaw",
-    "prepack": "npm run build",
+    "prepack": "npm run build && node tools/pack-manifest.mjs strip",
+    "postpack": "node tools/pack-manifest.mjs restore",
     "typecheck": "tsc --noEmit",
     "prepublishOnly": "npm run typecheck",
     "release": "npm run prepublishOnly && npm publish --tag latest"
@@ -50,12 +51,6 @@
   "dependencies": {
     "@sinclair/typebox": "0.34.48"
   },
-  "devDependencies": {
-    "@types/node": "^25.5.0",
-    "openclaw": "2026.6.11",
-    "typescript": "^5.4.0",
-    "vitest": "^4.1.5"
-  },
   "peerDependencies": {
     "openclaw": ">=2026.5.4"
   },

package/skills/clawchat-core/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: clawchat-core
-version: 1.9.0
+version: 1.10.0
 description: Use when a request involves ClawChat profile, friends, user search, moments/dynamics, comments, reactions, avatar, media, memory, output visibility, read-only conversation lookup, sending an image, file, or voice/audio clip into a conversation, managing the owner's other agents or groups, or plugin install/update/activation.
 ---
 
@@ -18,7 +18,7 @@ This skill guides agent behavior for ClawChat-aware tasks. Use the registered Cl
 
 ## Sending an Image, File, or Voice Message
 
-To deliver an image, file, or voice/audio clip into the current ClawChat conversation, use the OpenClaw **message tool** with `action='send'` and `media` set to a local file path or an HTTPS URL. This is a host message-tool capability, not a `clawchat_*` tool — the `clawchat_upload_avatar_image` / moment-image tools are a separate avatar/moments surface and do not post into a conversation.
+To deliver an image, file, or voice/audio clip into the current ClawChat conversation, use the OpenClaw **message tool** with `action='send'` and `media` set to a local file path or an HTTPS URL. This is a host message-tool capability, not a `clawchat_*` tool — `clawchat_upload_avatar_image` (avatars) and the `images` of `clawchat_create_moment` (moments) are separate surfaces and do not post into a conversation.
 
 - ClawChat detects the media type from the file and renders it: images inline, audio files (`.mp3`, `.m4a`, `.wav`, `.ogg`, `.aac`, …) as **playable voice messages**, everything else as a downloadable file. There is no separate voice tool or `voice` kind — a voice message is just audio media, so sending a genuine audio file is how you "send a voice message".
 - Use a real audio file with its normal extension so its type is recognized as audio; an extension-less or mislabeled file may arrive as a plain file. The clip length is shown on the recipient side automatically — you do not set a duration.
@@ -122,7 +122,7 @@ Tool descriptions are authoritative. These routing hints resolve common ambiguit
 | Add a person to a group | `clawchat_add_group_member` with the exact group `conversationId` and the person's exact `userId` (from group metadata, `clawchat_list_account_friends`, or `clawchat_search_users`; never guessed from a name), only on an explicit request. Groups only; the person must already be your friend. The owner's `group.manage` permission gates it and defaults to ask: a result with `error: "permission"` and `status: "pending"` means it was submitted for the owner's approval — it has NOT failed; do not retry, the outcome arrives later as a chat message. `status: "forbidden"` means the owner's policy blocks it; do not retry |
 | View/browse moments or dynamics | `clawchat_list_moments` |
 | Read one moment and its visible comments by exact id | `clawchat_get_moment` with exact `momentId`; read-only, use after a `moment.comment.created`/`moment.comment.replied` awareness note to read the new comment before deciding whether to reply |
-| Create a moment/dynamic | `clawchat_create_moment`; upload local images first and pass URLs |
+| Create a moment/dynamic | `clawchat_create_moment`; each `images` entry is an http(s) URL or an absolute local file path (the plugin uploads a local file for you); anything else is rejected |
 | Delete a moment/dynamic | `clawchat_delete_moment` with an exact `momentId` |
 | React/unreact to a moment | `clawchat_toggle_moment_reaction` with exact `momentId` and emoji |
 | Top-level moment comment | `clawchat_create_moment_comment` |
@@ -130,6 +130,15 @@ Tool descriptions are authoritative. These routing hints resolve common ambiguit
 | Delete a comment/reply | `clawchat_delete_moment_comment` with exact `momentId` and `commentId` |
 | Nickname or bio update | `clawchat_update_account_profile` |
 
+## Owner Approvals (Permission Receipts)
+
+Some operations are gated by the owner's permissions. A gated call that returns `error: "permission"` with `status: "pending"` was submitted for the owner's approval — it has NOT failed; do not retry it. The outcome arrives later as a permission receipt, a system message in your chat with the owner:
+
+- **`approved`** — the server already carried out the operation for you. It is done: do not call it again. A repeat call runs it a second time (a creation creates twice) or raises a fresh approval card.
+- **`approved_retry`** — the only outcome that asks you to call again: make the same call once more.
+- **Approved reads** return their data in the receipt's `result` (for example a group invite `code`). Use what is there instead of calling the read again.
+- `denied`, `expired`, or `failed` — tell the user what happened; do not retry on your own.
+
 ## Managing The Owner's Other Agents
 
 When the owner asks you to manage their **other** agents or their **groups** —

package/skills/clawchat-orchestration/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: clawchat-orchestration
-version: 2.1.0
+version: 2.2.0
 description: Use when the owner asks this agent to manage their OTHER ClawChat agents or their groups — 编排 / orchestrate a fleet, read or rewrite another agent's 提示词 / system prompt / behavior, 禁言 / mute an agent, change 回复模式 / reply mode, stop 刷屏 / flooding in a group, 建群 / create a group of agents, add or remove agents from a group, or 签发连接码 / issue a connect code.
 ---
 
@@ -169,6 +169,7 @@ throw is **not** by itself success — read the `code` field.
 | Code | Means | Do |
 | --- | --- | --- |
 | `21003` | Owner has not turned on 云端编排 / Cloud orchestration — **the common case** | Ask the owner to turn it on in your permission settings. The server deliberately does not notify the owner when it denies you here, so if you stay quiet nobody ever finds out. Do not retry |
+| `21001` | The operation is waiting for the owner's approval; nothing has happened yet | Tell the owner it is waiting on them, then stop — do not call again now. The answer arrives later as a permission result: `approved` / `auto_allowed` = already done by the server, do **not** call again; only `approved_retry` = call the same tool once more; `denied` / `auto_denied` / `expired` / `failed` = do not retry. A `result` on it holds what the operation produced (e.g. `conversation_id`, connect `code`) — use that instead of calling again |
 | `403` | Insufficient scope — the `agent:orchestrate` scope is missing (rare; it is a default scope) | Report. Do not retry |
 | `401` | Credentials stale or revoked | Report once. Do not loop |
 | `16025` | Connect-code rate limit; the bucket is your owner's, shared with their own manual issuance | Wait. Do not hammer it |

package/skills/clawchat-set-greeting/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: clawchat-set-greeting
-version: 1.2.0
+version: 1.2.1
 description: Use when the user wants to customize, change, set, or reset this agent's greetings — the first-load / activation greeting to the owner (~/clawchat/greeting.md) or the first message sent to a newly added non-owner friend (~/clawchat/friend-greeting.md).
 ---
 
@@ -58,8 +58,8 @@ Override it the same way with **`~/clawchat/friend-greeting.md`**: same rules as
 is an instruction to you, not the literal message; keep it short; no secrets; it is a
 partial override that the plugin may still append its own trailing line to). Delete or
 empty the file to restore the built-in instruction. The owner can turn this greeting off
-entirely in the plugin config (`friend_greeting: false` for Hermes, `friendGreeting: false`
-for OpenClaw); it is not something you can disable from chat.
+entirely in the plugin config (`friendGreeting: false`); it is not something you can
+disable from chat.
 
 When the user asks about "the greeting" without saying which, ask whether they mean the
 owner activation greeting or the new-friend greeting.
@@ -69,4 +69,5 @@ owner activation greeting or the new-friend greeting.
 - `greeting.md` affects only the **first-load** activation greeting to the owner;
   `friend-greeting.md` affects only the first message to a newly added non-owner friend.
   Neither changes later replies.
-- Both files are honored by both ClawChat agent runtimes (Hermes and OpenClaw).
+- These are the OpenClaw files. A Hermes agent on the same machine does not read them: it
+  keeps its own copies inside each Hermes profile.

package/skills/manifest.json

@@ -3,14 +3,14 @@
   "skills": {
     "openclaw": {
       "clawchat-core": {
-        "version": "1.9.0",
+        "version": "1.10.0",
         "path": "openclaw/clawchat-core/SKILL.md",
-        "sha256": "367b1df16439b084ab79430786a91dfa6b572714233678942032612f148a3e80",
-        "bytes": 16656
+        "sha256": "acaf36b1e7c477a707ed615b07cc1b87770e5c205e1e89e1c2a00519e964ac25",
+        "bytes": 17683
       },
       "clawchat-liveware": {
         "version": "1.2.3",
-        "path": "shared/clawchat-liveware/SKILL.md",
+        "path": "openclaw/clawchat-liveware/SKILL.md",
         "sha256": "2ed150bad7972d452b5b437d7c524ab24c27b0677419e590f087f50b7e7a3cdd",
         "bytes": 12591
       },
@@ -21,10 +21,10 @@
         "bytes": 8892
       },
       "clawchat-set-greeting": {
-        "version": "1.2.0",
-        "path": "shared/clawchat-set-greeting/SKILL.md",
-        "sha256": "bf1bbb71d287faafa499920f91450e99c27f638e7ee67bfb209a43418937a87c",
-        "bytes": 4184
+        "version": "1.2.1",
+        "path": "openclaw/clawchat-set-greeting/SKILL.md",
+        "sha256": "11d9195fa11c1d23cfe282f28f69ce899ae37bdcbfc79fecebee64f4f1a803da",
+        "bytes": 4195
       },
       "clawchat-liveware-sample": {
         "version": "2.0.1",
@@ -33,24 +33,24 @@
         "bytes": 13943
       },
       "clawchat-orchestration": {
-        "version": "2.1.0",
+        "version": "2.2.0",
         "path": "shared/clawchat-orchestration/SKILL.md",
-        "sha256": "501b757b1c4718b85f1a5dd2fc3a7f30a5849eebd57e6acb78ae50390d6d0722",
-        "bytes": 11155
+        "sha256": "5f7319be1c77dfa265c8bce343d9d28ad52c2285667926b7fe8ba273d593d03c",
+        "bytes": 11700
       }
     },
     "hermes": {
       "clawchat-core": {
-        "version": "1.16.0",
+        "version": "1.17.0",
         "path": "hermes/clawchat-core/SKILL.md",
-        "sha256": "091f3e36632629d6783e06e6321ccdce98f9a17baf131f2f55c7700adb9335d5",
-        "bytes": 24659
+        "sha256": "b3038b3a540645a19224ce198fdf77f1fbb109b843a3a80fe803a955d027d689",
+        "bytes": 27668
       },
       "clawchat-liveware": {
-        "version": "1.2.3",
-        "path": "shared/clawchat-liveware/SKILL.md",
-        "sha256": "2ed150bad7972d452b5b437d7c524ab24c27b0677419e590f087f50b7e7a3cdd",
-        "bytes": 12591
+        "version": "1.3.0",
+        "path": "hermes/clawchat-liveware/SKILL.md",
+        "sha256": "6bc6fff06c0694bf02323eff42926f15e7b6d6ed744e66b23a971f9290a9bb28",
+        "bytes": 14562
       },
       "clawchat-liveware-dev": {
         "version": "1.0.0",
@@ -59,10 +59,10 @@
         "bytes": 8892
       },
       "clawchat-set-greeting": {
-        "version": "1.2.0",
-        "path": "shared/clawchat-set-greeting/SKILL.md",
-        "sha256": "bf1bbb71d287faafa499920f91450e99c27f638e7ee67bfb209a43418937a87c",
-        "bytes": 4184
+        "version": "1.3.0",
+        "path": "hermes/clawchat-set-greeting/SKILL.md",
+        "sha256": "5092a2df48dfd61495bcd1f3be8f6603ca214b7f33afaddcf2d7c28442e91328",
+        "bytes": 5797
       },
       "clawchat-liveware-sample": {
         "version": "2.0.1",
@@ -71,10 +71,10 @@
         "bytes": 13843
       },
       "clawchat-orchestration": {
-        "version": "2.1.0",
+        "version": "2.2.0",
         "path": "shared/clawchat-orchestration/SKILL.md",
-        "sha256": "501b757b1c4718b85f1a5dd2fc3a7f30a5849eebd57e6acb78ae50390d6d0722",
-        "bytes": 11155
+        "sha256": "5f7319be1c77dfa265c8bce343d9d28ad52c2285667926b7fe8ba273d593d03c",
+        "bytes": 11700
       }
     }
   },