@clawling/clawchat-plugin-openclaw 2026.8.4-2 → 2026.8.5-2

package/dist/src/friend-request-turn.js

@@ -0,0 +1,83 @@
+/**
+ * Synthetic reasoning-turn builder for `friend.request` notify.signal events.
+ *
+ * When the server fires a `friend.request` signal the runtime dispatches one
+ * deduped synthetic `message.send` envelope so the agent can reason about the
+ * pending request. The prompt text varies by the current "friend.add" permission
+ * policy state: a deny policy yields a decline/inform prompt; ask or allow
+ * yields a prompt that instructs the agent to review the request via the
+ * `clawchat_list_friend_requests` tool.
+ */
+import { EVENT } from "./protocol-types.js";
+/**
+ * Returns canned prompt text for a friend-request reasoning turn based on the
+ * current "friend.add" permission policy state.
+ *
+ * - `deny`  → inform the agent it should decline; no accept instruction.
+ * - `ask` / `allow` → instruct the agent to review the pending request.
+ *
+ * The requester's user id is embedded so the agent does not go looking up the
+ * synthetic sender ("clawchat-friend-request" is not a real user).
+ */
+export function friendRequestPromptFor(state, requesterUserId) {
+    const arrived = requesterUserId
+        ? `A new friend request has arrived from user ${requesterUserId}.`
+        : "A new friend request has arrived.";
+    if (state === "deny") {
+        return [
+            arrived,
+            "Your current friend-add policy is set to deny.",
+            "Do not add this contact.",
+            "You may inform the requester that you cannot add them at this time.",
+        ].join(" ");
+    }
+    return [
+        arrived,
+        "Please review the pending request by calling `clawchat_list_friend_requests`",
+        "and decide whether to accept it.",
+    ].join(" ");
+}
+/**
+ * Builds a synthetic `message.send` envelope that triggers one agent reasoning
+ * turn for a pending friend request. The envelope shape mirrors the
+ * activation-bootstrap envelope; it targets the owner's direct conversation so
+ * the agent has context about who it is reasoning for.
+ */
+export function buildFriendRequestEnvelope(params) {
+    const { account, state, entityId, ownerConversationId } = params;
+    const text = friendRequestPromptFor(state, entityId);
+    const now = Date.now();
+    // Fall back to ownerUserId only when no activation conversation is recorded:
+    // the turn still runs (the agent can act via tools, e.g. accept the request),
+    // but its in-chat replies will not be deliverable until activation records
+    // the owner conversation.
+    return {
+        version: "2",
+        event: EVENT.MESSAGE_SEND,
+        trace_id: `clawchat-plugin-openclaw-friend-request-${entityId}-${now}`,
+        emitted_at: now,
+        chat_id: ownerConversationId ?? account.ownerUserId,
+        chat_type: "direct",
+        to: { id: account.userId, type: "direct" },
+        sender: {
+            id: "clawchat-friend-request",
+            type: "direct",
+            nick_name: "ClawChat",
+        },
+        payload: {
+            message_id: `clawchat-plugin-openclaw-friend-request-${entityId}-${now}`,
+            message_mode: "normal",
+            message: {
+                body: { fragments: [{ kind: "text", text }] },
+                context: { mentions: [], reply: null },
+                streaming: {
+                    status: "static",
+                    sequence: 0,
+                    mutation_policy: "sealed",
+                    started_at: null,
+                    completed_at: null,
+                },
+            },
+        },
+    };
+}

package/dist/src/runtime.js

@@ -2803,6 +2803,37 @@ export async function startOpenclawClawlingGateway(params) {
                 conversationId: claimedBootstrap.conversationId,
             }));
         };
+        const markBootstrapSent = (reason) => {
+            if (!bootstrap)
+                return;
+            const claimedBootstrap = bootstrap;
+            const marked = recordConnection("activation bootstrap sent", () => store.markActivationBootstrapSent?.({
+                platform: "openclaw",
+                accountId,
+                conversationId: claimedBootstrap.conversationId,
+            }));
+            if (marked !== true) {
+                // The UPDATE is guarded on bootstrap_sent = 0 AND bootstrap_claimed_at
+                // IS NOT NULL, so a stale re-claim makes this a no-op — and the row
+                // then stays re-greetable on every later reconnect. Never swallow it.
+                log?.error?.(`[${accountId}] clawchat-plugin-openclaw activation bootstrap not marked sent (${reason}); the greeting may repeat on reconnect`);
+            }
+            // Delivered — stop any pending retry.
+            clearBootstrapRetry();
+        };
+        // Single decision point for every exit after the claim. The greeting is
+        // emitted *inside* the dispatched turn, so once it has reached the user the
+        // claim must never be rolled back: releasing it lets the next connection
+        // claim again and greet a second time. Only a turn that delivered nothing
+        // is safe to retry.
+        const settleBootstrap = (reason) => {
+            if (bootstrapGreetingDelivered) {
+                markBootstrapSent(reason);
+                return;
+            }
+            releaseBootstrap();
+            armBootstrapRetry();
+        };
         try {
             bootstrap = recordConnection("activation bootstrap claim", () => store.claimPendingActivationBootstrap?.({ platform: "openclaw", accountId }));
             if (!bootstrap) {
@@ -2819,8 +2850,7 @@ export async function startOpenclawClawlingGateway(params) {
             bootstrapGreetingDelivered = false;
             const result = await handleInboundEnvelope(buildActivationBootstrapEnvelope({ account, conversationId: claimedBootstrap.conversationId }));
             if (result !== "submitted") {
-                releaseBootstrap();
-                armBootstrapRetry();
+                settleBootstrap("turn was not submitted");
                 return;
             }
             // Only mark the bootstrap done once the greeting was actually delivered
@@ -2831,21 +2861,11 @@ export async function startOpenclawClawlingGateway(params) {
             // rather than silently consuming it forever or waiting for the next reconnect.
             if (!bootstrapGreetingDelivered) {
                 log?.info?.(`[${accountId}] clawchat-plugin-openclaw activation bootstrap dispatched but greeting was not delivered; leaving pending for retry`);
-                releaseBootstrap();
-                armBootstrapRetry();
-                return;
             }
-            recordConnection("activation bootstrap sent", () => store.markActivationBootstrapSent?.({
-                platform: "openclaw",
-                accountId,
-                conversationId: claimedBootstrap.conversationId,
-            }));
-            // Delivered — stop any pending retry.
-            clearBootstrapRetry();
+            settleBootstrap("turn submitted");
         }
         catch (err) {
-            releaseBootstrap();
-            armBootstrapRetry();
+            settleBootstrap("dispatch threw");
             log?.error?.(`[${accountId}] clawchat-plugin-openclaw activation bootstrap failed: ${err instanceof Error ? err.message : String(err)}`);
         }
         finally {

package/dist/src/skill-update.js

@@ -55,10 +55,18 @@ import { fileURLToPath } from "node:url";
  */
 export const OFFICIAL_SKILLS_BASE = "https://raw.githubusercontent.com/clawling/clawchat-plugin-install-cli";
 /**
- * Default git ref for the skills tree. Production callers SHOULD pin an
- * immutable `skills-vX.Y.Z` tag instead of tracking the moving `main`.
+ * Default git ref for the skills tree — an immutable `skills-vX.Y.Z` tag, not
+ * the moving `main`. Nothing supplies a target version today (the trigger
+ * signal is content-free), so this constant is the ref every fetch uses: on
+ * `main` a released plugin would follow whatever landed in the skills tree
+ * since, and convergence compares raw bytes, so an in-progress edit is enough
+ * to prompt the owner for an "update".
+ *
+ * Moving the pin is a deliberate release: publish the new `skills-vX.Y.Z` tag
+ * 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 = "main";
+export const DEFAULT_SKILLS_REF = "skills-v1.6.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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@clawling/clawchat-plugin-openclaw",
-  "version": "2026.8.4-2",
+  "version": "2026.8.5-2",
   "description": "OpenClaw ClawChat channel plugin",
   "license": "MIT",
   "author": "CLAWLING PTE. LTD.",

package/skills/manifest.json

@@ -29,10 +29,10 @@
     },
     "hermes": {
       "clawchat-core": {
-        "version": "1.4.1",
+        "version": "1.7.0",
         "path": "hermes/clawchat-core/SKILL.md",
-        "sha256": "33488a7a77a1bd950e2d791420370cac27cc9d8717042251d6df5f8b781dc904",
-        "bytes": 11992
+        "sha256": "ea5118a99ddad7c9ce9c1437a4e33fbd76f45572998bb1722a70f4aa5e0e76aa",
+        "bytes": 17557
       },
       "clawchat-liveware": {
         "version": "1.1.0",

package/src/runtime.ts

@@ -3333,6 +3333,40 @@ export async function startOpenclawClawlingGateway(params: StartGatewayParams):
         }),
       );
     };
+    const markBootstrapSent = (reason: string) => {
+      if (!bootstrap) return;
+      const claimedBootstrap = bootstrap;
+      const marked = recordConnection("activation bootstrap sent", () =>
+        store.markActivationBootstrapSent?.({
+          platform: "openclaw",
+          accountId,
+          conversationId: claimedBootstrap.conversationId,
+        }),
+      );
+      if (marked !== true) {
+        // The UPDATE is guarded on bootstrap_sent = 0 AND bootstrap_claimed_at
+        // IS NOT NULL, so a stale re-claim makes this a no-op — and the row
+        // then stays re-greetable on every later reconnect. Never swallow it.
+        log?.error?.(
+          `[${accountId}] clawchat-plugin-openclaw activation bootstrap not marked sent (${reason}); the greeting may repeat on reconnect`,
+        );
+      }
+      // Delivered — stop any pending retry.
+      clearBootstrapRetry();
+    };
+    // Single decision point for every exit after the claim. The greeting is
+    // emitted *inside* the dispatched turn, so once it has reached the user the
+    // claim must never be rolled back: releasing it lets the next connection
+    // claim again and greet a second time. Only a turn that delivered nothing
+    // is safe to retry.
+    const settleBootstrap = (reason: string) => {
+      if (bootstrapGreetingDelivered) {
+        markBootstrapSent(reason);
+        return;
+      }
+      releaseBootstrap();
+      armBootstrapRetry();
+    };
     try {
       bootstrap = recordConnection("activation bootstrap claim", () =>
         store.claimPendingActivationBootstrap?.({ platform: "openclaw", accountId }),
@@ -3352,8 +3386,7 @@ export async function startOpenclawClawlingGateway(params: StartGatewayParams):
         buildActivationBootstrapEnvelope({ account, conversationId: claimedBootstrap.conversationId }),
       );
       if (result !== "submitted") {
-        releaseBootstrap();
-        armBootstrapRetry();
+        settleBootstrap("turn was not submitted");
         return;
       }
       // Only mark the bootstrap done once the greeting was actually delivered
@@ -3366,22 +3399,10 @@ export async function startOpenclawClawlingGateway(params: StartGatewayParams):
         log?.info?.(
           `[${accountId}] clawchat-plugin-openclaw activation bootstrap dispatched but greeting was not delivered; leaving pending for retry`,
         );
-        releaseBootstrap();
-        armBootstrapRetry();
-        return;
       }
-      recordConnection("activation bootstrap sent", () =>
-        store.markActivationBootstrapSent?.({
-          platform: "openclaw",
-          accountId,
-          conversationId: claimedBootstrap.conversationId,
-        }),
-      );
-      // Delivered — stop any pending retry.
-      clearBootstrapRetry();
+      settleBootstrap("turn submitted");
     } catch (err) {
-      releaseBootstrap();
-      armBootstrapRetry();
+      settleBootstrap("dispatch threw");
       log?.error?.(
         `[${accountId}] clawchat-plugin-openclaw activation bootstrap failed: ${err instanceof Error ? err.message : String(err)}`,
       );

package/src/skill-update.ts

@@ -60,10 +60,18 @@ export const OFFICIAL_SKILLS_BASE =
   "https://raw.githubusercontent.com/clawling/clawchat-plugin-install-cli";
 
 /**
- * Default git ref for the skills tree. Production callers SHOULD pin an
- * immutable `skills-vX.Y.Z` tag instead of tracking the moving `main`.
+ * Default git ref for the skills tree — an immutable `skills-vX.Y.Z` tag, not
+ * the moving `main`. Nothing supplies a target version today (the trigger
+ * signal is content-free), so this constant is the ref every fetch uses: on
+ * `main` a released plugin would follow whatever landed in the skills tree
+ * since, and convergence compares raw bytes, so an in-progress edit is enough
+ * to prompt the owner for an "update".
+ *
+ * Moving the pin is a deliberate release: publish the new `skills-vX.Y.Z` tag
+ * 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 = "main";
+export const DEFAULT_SKILLS_REF = "skills-v1.6.0";
 
 /** Refuse to treat an absurdly large response as a skill file (defence in depth). */
 export const MAX_SKILL_BYTES = 256 * 1024;