@clawling/clawchat-plugin-openclaw 2026.6.24-1 → 2026.6.30-2

package/src/inbound.ts

@@ -69,6 +69,18 @@ export interface DispatchInboundParams {
   runtime: PluginRuntime;
   account: ResolvedOpenclawClawlingAccount;
   ingest: (params: IngestTurnParams) => Promise<void>;
+  /**
+   * Pending-consent gate for conversational skill hot-update (see
+   * `src/skill-update.ts`). Called for direct messages from the owner BEFORE
+   * normal dispatch. Returns `true` when the reply was consumed as a consent
+   * decision (affirm/deny) and must NOT reach the LLM; `false` to let the
+   * message flow on normally (no pending update, or an ambiguous reply).
+   */
+  consumeOwnerConsent?: (args: {
+    senderId: string;
+    text: string;
+    chatId: string;
+  }) => Promise<boolean>;
   log?: { info?: (m: string) => void; error?: (m: string) => void };
 }
 
@@ -272,6 +284,35 @@ export async function dispatchOpenclawClawlingInbound(
     userId: account.userId,
   });
 
+  // Pending-consent gate for conversational skill hot-update. Only owner direct
+  // messages can answer a pending skill-update ask; the gate parses consent
+  // conservatively and, when it consumes the reply (affirm/deny), the message
+  // does NOT continue to the LLM. Ambiguous/unrelated replies return false and
+  // flow on normally (pending survives until timeout). See src/skill-update.ts.
+  if (
+    chatType === "direct" &&
+    params.consumeOwnerConsent &&
+    account.ownerUserId &&
+    sender.id === account.ownerUserId
+  ) {
+    let consumed = false;
+    try {
+      consumed = await params.consumeOwnerConsent({ senderId: sender.id, text: rawBody, chatId });
+    } catch (err) {
+      log?.error?.(
+        `[${account.accountId}] clawchat-plugin-openclaw skill-update consent gate error msg=${payload.message_id}: ${
+          err instanceof Error ? err.message : String(err)
+        }`,
+      );
+    }
+    if (consumed) {
+      log?.info?.(
+        `[${account.accountId}] clawchat-plugin-openclaw owner reply consumed as skill-update consent msg=${payload.message_id}`,
+      );
+      return;
+    }
+  }
+
   // NOTE: the static mention-mode early-drop was removed here (Task 7 fix).
   // Non-mention group messages now always flow through to ingestTurn, which
   // applies the dynamic gate (GroupSettingsCache.effective) and returns

package/src/login.runtime.ts

@@ -2,6 +2,7 @@ import { createInterface, type Interface as ReadlineInterface } from "node:readl
 import type { OpenClawConfig } from "openclaw/plugin-sdk/core";
 import { createOpenclawClawlingApiClient } from "./api-client.ts";
 import { ClawlingApiError, type AgentConnectResult } from "./api-types.ts";
+import { resolvePluginVersion } from "./plugin-report.ts";
 import {
   CHANNEL_ID,
   mergeOpenclawClawchatRuntimePluginActivation,
@@ -197,6 +198,7 @@ export async function runOpenclawClawlingLogin(params: LoginParams): Promise<voi
     // Pre-login we may not have a token yet. Send the current one (or empty)
     // — the server should accept an unauthenticated invite-code exchange.
     token: account.token || "",
+    pluginVersion: resolvePluginVersion(),
   });
 
   runtime.log("Verifying invite code …");

package/src/reply-dispatcher.ts

@@ -546,7 +546,7 @@ export function createOpenclawClawlingReplyDispatcher(options: ReplyDispatcherOp
 
   // §7.6 (binding): client-supplied message_id MUST be `msg-` + a 26-char
   // Crockford base32 ULID. Use the shared conformant minter — do not invent a
-  // different scheme (planned msghub Phase-4 validation will reject it).
+  // different scheme (planned backend validation will reject it).
   const mintStaticMessageId = () => mintMessageId();
 
   const emitTyping = (isTyping: boolean) => {

package/src/runtime.ts

@@ -35,6 +35,14 @@ import {
 } from "./config.ts";
 import type { ClawlingChatClient } from "./ws-client.ts";
 import { dispatchOpenclawClawlingInbound, type IngestTurnParams } from "./inbound.ts";
+import {
+  PendingConsentStore,
+  handleOwnerConsentReply,
+  readEffectiveSkillVersions,
+  resolveBundledSkillsDir,
+  resolveManagedSkillsDir,
+  runSkillUpdateCheck,
+} from "./skill-update.ts";
 import { fetchInboundMedia } from "./media-runtime.ts";
 import { createOpenclawClawlingReplyDispatcher } from "./reply-dispatcher.ts";
 import { runWithTerminalClawChatSendScope } from "./terminal-send.ts";
@@ -419,12 +427,17 @@ function withClawChatSessionScope(cfg: OpenClawConfig): OpenClawConfig {
 }
 
 function buildActivationBootstrapText(): string {
+  // Worded to make the greeting the single required action. Earlier wording
+  // ("ClawChat activation bootstrap: ... do both ...") led some agents to treat
+  // it as a setup task and write a `BOOTSTRAP.md` file instead of replying, so
+  // no greeting reached the user. Lead with the chat reply, forbid file/tool
+  // detours, and keep the profile update strictly optional and secondary.
   return [
-    "ClawChat activation bootstrap: You are now connected to this ClawChat direct conversation.",
-    "Please do both:",
-    "1. Send a brief, friendly greeting to the user in this ClawChat direct conversation.",
-    "2. If you have local profile information for yourself, such as display name, bio, or avatar, update the connected ClawChat account profile using the available ClawChat tools. Use `clawchat_update_account_profile` for display name/bio/avatar URL, and use `clawchat_upload_avatar_image` first if the avatar is only available as a local image path. If you do not have local profile information, skip profile updates and only greet the user.",
-    "Do not ask the user for profile information just for this bootstrap.",
+    "You are now connected to a ClawChat direct conversation with your user.",
+    "Reply now with one short, friendly greeting message in this conversation: introduce yourself and say you are connected and ready.",
+    "Send it as a normal chat reply. Do not write or create any files or notes, and do not call tools just to greet.",
+    "Only if you already have your own profile details (display name, bio, or avatar) may you also call `clawchat_update_account_profile` (use `clawchat_upload_avatar_image` first for a local avatar image); otherwise skip that and just greet.",
+    "Do not ask the user for profile information.",
   ].join("\n");
 }
 
@@ -1808,6 +1821,11 @@ export async function startOpenclawClawlingGateway(params: StartGatewayParams):
     );
   };
   let dispatchActivationBootstrap: () => Promise<void> = async () => {};
+  // Set by dispatchTurnToAgent when it dispatches the synthetic
+  // `clawchat-bootstrap` turn: true only if the agent actually produced a final
+  // outbound message (the greeting). The bootstrap dispatcher reads it to decide
+  // whether to mark the bootstrap sent or leave it pending for a later retry.
+  let bootstrapProducedFinal = false;
 
   client.on("state", ({ from, to }) => {
     log?.info?.(`[${accountId}] clawchat-plugin-openclaw state ${from} -> ${to}`);
@@ -2038,6 +2056,83 @@ export async function startOpenclawClawlingGateway(params: StartGatewayParams):
     void handleMetadataInvalidation(env);
   });
 
+  // --- Conversational skill hot-update (adapter-driven; see src/skill-update.ts) ---
+  // One pending-consent record per runtime.
+  // WRITE target = the OpenClaw-managed skills dir (`<stateDir>/skills`): it is
+  // chokidar-watched (host src/skills/runtime/refresh.ts:107) so a write bumps
+  // the snapshot + rebuilds the prompt next turn, and it loads at HIGHER
+  // precedence than plugin-bundled skills (managed=3 > bundled=2, host
+  // src/skills/loading/workspace.ts:1220-1239), overriding the bundled copy.
+  // The bundled `./skills` dir is READ-ONLY here: a first-boot fallback for the
+  // "current installed version" only — never written (it lives in node_modules
+  // → may be read-only and is clobbered on `openclaw plugins update`).
+  const skillUpdateConsent = new PendingConsentStore();
+  const managedSkillsDir = resolveManagedSkillsDir();
+  let bundledSkillsDir: string | null = null;
+  try {
+    bundledSkillsDir = resolveBundledSkillsDir();
+  } catch (err) {
+    log?.info?.(
+      `[${accountId}] clawchat-plugin-openclaw skill-update: bundled skills dir not resolvable (using managed-only current): ${
+        err instanceof Error ? err.message : String(err)
+      }`,
+    );
+  }
+  const sendOwnerSkillMessage = async (text: string): Promise<void> => {
+    const ownerUserId = account.ownerUserId?.trim();
+    if (!ownerUserId) return;
+    await sendOpenclawClawlingText({
+      client,
+      account,
+      to: { chatId: ownerUserId, chatType: "direct" },
+      text,
+      log,
+    });
+  };
+  const triggerSkillUpdateCheck = async (): Promise<void> => {
+    const ownerUserId = account.ownerUserId?.trim();
+    if (!ownerUserId) {
+      log?.info?.(
+        `[${accountId}] clawchat-plugin-openclaw skill-update check skipped: no owner user id`,
+      );
+      return;
+    }
+    // Effective current = managed copy if present, else bundled (host precedence).
+    const localVersions = await readEffectiveSkillVersions(managedSkillsDir, bundledSkillsDir);
+    await runSkillUpdateCheck({
+      ownerUserId,
+      localVersions,
+      fetchFn: globalThis.fetch,
+      store: skillUpdateConsent,
+      sendOwnerMessage: sendOwnerSkillMessage,
+      log: {
+        info: (m) => log?.info?.(`[${accountId}] clawchat-plugin-openclaw ${m}`),
+        error: (m) => log?.error?.(`[${accountId}] clawchat-plugin-openclaw ${m}`),
+      },
+    });
+  };
+  const consumeOwnerSkillConsent = async (args: {
+    senderId: string;
+    text: string;
+    chatId: string;
+  }): Promise<boolean> => {
+    const ownerUserId = account.ownerUserId?.trim();
+    if (!ownerUserId) return false;
+    return handleOwnerConsentReply({
+      ownerUserId,
+      senderId: args.senderId,
+      text: args.text,
+      store: skillUpdateConsent,
+      fetchFn: globalThis.fetch,
+      skillsDir: managedSkillsDir,
+      sendOwnerMessage: sendOwnerSkillMessage,
+      log: {
+        info: (m) => log?.info?.(`[${accountId}] clawchat-plugin-openclaw ${m}`),
+        error: (m) => log?.error?.(`[${accountId}] clawchat-plugin-openclaw ${m}`),
+      },
+    });
+  };
+
   client.on("notify:signal", (env: Envelope) => {
     // §9.4 reliable system notification. The plugin holds no friend/roster
     // cache (friends are fetched on demand via REST tools), so there is nothing
@@ -2054,6 +2149,20 @@ export async function startOpenclawClawlingGateway(params: StartGatewayParams):
           `[${accountId}] clawchat-plugin-openclaw agent.config.changed signal received; re-pulling group settings`,
         );
         pullGroupSettings();
+      } else if (type === "clawchat.skill.update.check") {
+        // Content-free trigger: check the official skill source in code and, if
+        // there is an update, ask the owner in chat for consent. The atomic
+        // overwrite happens later when the owner affirms (consent gate).
+        log?.info?.(
+          `[${accountId}] clawchat-plugin-openclaw clawchat.skill.update.check signal received; checking official skill source`,
+        );
+        void triggerSkillUpdateCheck().catch((err) => {
+          log?.error?.(
+            `[${accountId}] clawchat-plugin-openclaw skill-update check failed: ${
+              err instanceof Error ? err.message : String(err)
+            }`,
+          );
+        });
       }
     }
   });
@@ -2480,6 +2589,12 @@ export async function startOpenclawClawlingGateway(params: StartGatewayParams):
         const queuedFinal = Boolean(
           (dispatchResult as { queuedFinal?: boolean } | undefined)?.queuedFinal,
         );
+        if (turn.senderId === "clawchat-bootstrap") {
+          // Did the agent actually emit a greeting? A final outbound message
+          // means yes; block/tool-only (or nothing) means the greeting never
+          // reached the user, so the bootstrap dispatcher will keep it pending.
+          bootstrapProducedFinal = queuedFinal || (counts.final ?? 0) > 0;
+        }
         log?.info?.(
           `[${accountId}] clawchat-plugin-openclaw dispatch complete msg=${turn.messageId} queuedFinal=${queuedFinal} counts=${JSON.stringify(counts)}`,
         );
@@ -2744,6 +2859,7 @@ export async function startOpenclawClawlingGateway(params: StartGatewayParams):
         runtime,
         account,
         log,
+        consumeOwnerConsent: consumeOwnerSkillConsent,
         ingest: async (turn) => {
           ingestResult = await ingestTurn(turn);
         },
@@ -2777,6 +2893,7 @@ export async function startOpenclawClawlingGateway(params: StartGatewayParams):
       );
       if (!bootstrap) return;
       const claimedBootstrap = bootstrap;
+      bootstrapProducedFinal = false;
       const result = await handleInboundEnvelope(
         buildActivationBootstrapEnvelope({ account, conversationId: claimedBootstrap.conversationId }),
       );
@@ -2784,6 +2901,18 @@ export async function startOpenclawClawlingGateway(params: StartGatewayParams):
         releaseBootstrap();
         return;
       }
+      // Only mark the bootstrap done once the agent has actually sent a greeting
+      // (a final outbound message). If the turn was handed off but produced no
+      // final reply — e.g. the agent went off to write a file/note instead of
+      // replying — leave the bootstrap pending (release the claim) so the next
+      // ready re-dispatches it, rather than silently consuming it forever.
+      if (!bootstrapProducedFinal) {
+        log?.info?.(
+          `[${accountId}] clawchat-plugin-openclaw activation bootstrap dispatched but produced no final reply; leaving pending for retry`,
+        );
+        releaseBootstrap();
+        return;
+      }
       recordConnection("activation bootstrap sent", () =>
         store.markActivationBootstrapSent?.({
           platform: "openclaw",