@clawling/clawchat-plugin-openclaw 2026.7.2 → 2026.7.6-2

package/dist/src/activation-greeting.js

@@ -0,0 +1,34 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+// 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.
+const ACTIVATION_BOOTSTRAP_FALLBACK = [
+    "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");
+// Cross-plugin, user-editable override read lazily so edits apply on the next
+// first-load without a restart. Any read failure falls back to the built-in text.
+export function buildActivationBootstrapText(homeDir = os.homedir()) {
+    const greetingPath = path.join(homeDir, "clawchat", "greeting.md");
+    try {
+        const raw = fs.readFileSync(greetingPath);
+        const override = new TextDecoder("utf-8", { fatal: true }).decode(raw).trim();
+        if (override.length > 0) {
+            return override;
+        }
+    }
+    catch (error) {
+        const code = error.code;
+        if (code !== "ENOENT") {
+            console.warn(`clawchat.greeting failed to read override ${greetingPath}:`, error);
+        }
+    }
+    return ACTIVATION_BOOTSTRAP_FALLBACK;
+}

package/dist/src/api-client.js

@@ -5,6 +5,7 @@ export function buildPluginReportBody(input) {
         device_id: input.deviceId,
         platform: input.platform,
         plugin_version: input.pluginVersion,
+        agent_version: input.agentVersion,
         runtime_name: input.runtimeName,
         runtime_version: input.runtimeVersion,
     };

package/dist/src/config.js

@@ -216,7 +216,7 @@ function decodeJwtStringClaim(token, claim) {
  * userId that disagrees with `sub` is always wrong for the session this token
  * creates, and it silently breaks self-echo detection: with the OWNER's id
  * here, every owner message is dropped as the bot's own echo (2026-07-02
- * clawnest incident — a provisioner wrote the owner id into the config). Token
+ * production incident — a provisioner wrote the owner id into the config). Token
  * wins; the mismatch is logged. Also derives userId from `sub` when nothing is
  * configured, mirroring the `oid` fallback above.
  */

package/dist/src/plugin-report.js

@@ -53,6 +53,7 @@ export async function reportPluginVersionSafe(p) {
             deviceId: p.deviceId,
             platform: "openclaw",
             pluginVersion: p.pluginVersion,
+            agentVersion: p.agentVersion,
             runtimeName: "node",
             runtimeVersion: process.version,
         }, { authenticated: p.authenticated });

package/dist/src/refresh-manager.js

@@ -24,6 +24,13 @@ export const MIN_REFRESH_INTERVAL_MS = 30_000;
 export const PROACTIVE_JITTER_MS = 5 * MINUTE_MS;
 /** §A.0 — fallback access-token TTL when `exp` is unparseable. */
 export const ACCESS_TOKEN_TTL_MS = 24 * HOUR_MS;
+/**
+ * §A.1 — Node stores a `setTimeout` delay in a signed 32-bit int; a delay above
+ * this silently clamps to 1ms and fires *immediately*. Long-lived (~30-day)
+ * access tokens push `refresh_at - now` well past this, so the proactive wait is
+ * chunked into at-most-this-long sleeps that re-arm until the real time.
+ */
+export const MAX_TIMER_DELAY_MS = 2_147_483_647; // 2^31 - 1
 /**
  * §A.0/§A.1 — compute the absolute epoch-ms at which to proactively refresh.
  * `refresh_at = exp - max(30min, min(2h, 0.25 * (exp - iat)))` plus jitter.
@@ -204,6 +211,18 @@ export class RefreshManager {
             jitterMs,
         });
         const delayMs = Math.max(0, refreshAtMs - this.now());
+        if (delayMs > MAX_TIMER_DELAY_MS) {
+            // Too far out for a single setTimeout without 32-bit overflow (which would
+            // fire at 1ms and trigger an immediate refresh + WS reconnect, cancelling
+            // any in-flight send). Sleep one max chunk, then re-arm from the still-live
+            // token for the remaining wait.
+            this.ports.log?.debug?.(`clawchat-plugin-openclaw proactive timer chunked delayMs=${delayMs} chunk=${MAX_TIMER_DELAY_MS}`);
+            this.proactiveTimer = this.setTimer(() => {
+                this.proactiveTimer = null;
+                this.armProactiveTimer(activatedAtMs);
+            }, MAX_TIMER_DELAY_MS);
+            return;
+        }
         this.ports.log?.debug?.(`clawchat-plugin-openclaw proactive timer armed delayMs=${delayMs}`);
         this.proactiveTimer = this.setTimer(() => {
             this.proactiveTimer = null;

package/dist/src/runtime.js

@@ -4,6 +4,7 @@ import { hasControlCommand } from "openclaw/plugin-sdk/command-detection";
 import { createPluginRuntimeStore } from "openclaw/plugin-sdk/runtime-store";
 import { createOpenclawClawlingClient, resolveOpenclawClawlingDeviceId } from "./client.js";
 import { createOpenclawClawlingApiClient } from "./api-client.js";
+import { buildActivationBootstrapText } from "./activation-greeting.js";
 import { reportPluginVersionSafe, resolvePluginVersion } from "./plugin-report.js";
 import { ensureLivewareCli } from "./liveware-cli.js";
 import { ClawlingApiError } from "./api-types.js";
@@ -11,7 +12,7 @@ import { RefreshManager } from "./refresh-manager.js";
 import { runOpenclawClawlingLogin, } from "./login.runtime.js";
 import { CHANNEL_ID, effectiveOutputVisibility, effectiveGroupCommandMode, effectiveGroupMode, hasOpenclawClawlingConnectCredentials, resolveOpenclawClawlingAccount, } from "./config.js";
 import { dispatchOpenclawClawlingInbound } from "./inbound.js";
-import { PendingConsentStore, handleOwnerConsentReply, readEffectiveSkillVersions, resolveBundledSkillsDir, resolveManagedSkillsDir, runSkillUpdateCheck, } from "./skill-update.js";
+import { PendingConsentStore, handleOwnerConsentReply, managedSkillExists, readLocalSkillState, resolveBundledSkillsDir, resolveManagedSkillsDir, runSkillUpdateCheck, } from "./skill-update.js";
 import { fetchInboundMedia } from "./media-runtime.js";
 import { createOpenclawClawlingReplyDispatcher } from "./reply-dispatcher.js";
 import { runWithTerminalClawChatSendScope } from "./terminal-send.js";
@@ -309,20 +310,6 @@ function withClawChatSessionScope(cfg) {
         },
     };
 }
-function buildActivationBootstrapText() {
-    // 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 [
-        "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");
-}
 function buildActivationBootstrapEnvelope(params) {
     const text = buildActivationBootstrapText();
     const now = Date.now();
@@ -574,6 +561,26 @@ function waitForActivationPoll(abortSignal, ms) {
 async function waitForActivationCredentials(params) {
     const { abortSignal, getStatus, setStatus, store, log } = params;
     const accountId = params.account.accountId;
+    // SQLite-first: activation and token rotation persist to the activations
+    // row, so a complete row is the durable credential source of truth even
+    // when channel config/env also carries credentials. Config/env credentials
+    // only bootstrap the no-row case (the caller seeds a row from them).
+    if (store?.getActivationCredentials) {
+        const stored = store.getActivationCredentials({ platform: "openclaw", accountId });
+        if (stored && stored.accessToken !== params.rejectedActivationToken) {
+            log?.info?.(`[${accountId}] clawchat-plugin-openclaw loaded activation credentials from sqlite`);
+            return {
+                source: "sqlite",
+                account: {
+                    ...params.account,
+                    configured: true,
+                    token: stored.accessToken,
+                    userId: stored.userId,
+                    ownerUserId: stored.ownerUserId,
+                },
+            };
+        }
+    }
     if (accountHasConnectCredentials(params.account)) {
         return { account: params.account, source: "configured" };
     }
@@ -647,12 +654,14 @@ export async function startOpenclawClawlingGateway(params) {
     // so the backend links both to the same row. Imported from ./client.ts.
     const reportDeviceId = resolveOpenclawClawlingDeviceId(account);
     const pluginVersion = resolvePluginVersion();
+    const agentVersion = runtime.version ?? "";
     void reportPluginVersionSafe({
         baseUrl: account.baseUrl,
         mediaBaseUrl: account.mediaBaseUrl,
         token: "",
         deviceId: reportDeviceId,
         pluginVersion,
+        agentVersion,
         authenticated: false,
         log,
     });
@@ -693,6 +702,26 @@ export async function startOpenclawClawlingGateway(params) {
     if (!activationAccount)
         return;
     account = activationAccount.account;
+    // Config/env bootstrap seeding: converge on SQLite as the single durable
+    // credential store, so token rotation always has a row to update and the
+    // next startup resolves SQLite-first to the same credentials.
+    if (activationAccount.source === "configured" && store?.upsertActivation) {
+        try {
+            store.upsertActivation({
+                platform: "openclaw",
+                accountId,
+                userId: account.userId,
+                ownerUserId: account.ownerUserId,
+                accessToken: account.token,
+                refreshToken: readConfigRefreshToken(cfg),
+                loginMethod: "config-seed",
+                deviceId: CHANNEL_ID,
+            });
+        }
+        catch (error) {
+            log?.error?.(`[${accountId}] clawchat-plugin-openclaw sqlite credential seed failed; continuing with config credentials: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
     // Paired: link the report row via the authenticated endpoint, reusing the
     // SAME frozen device_id so the backend upserts the existing unpaired row.
     void reportPluginVersionSafe({
@@ -701,12 +730,15 @@ export async function startOpenclawClawlingGateway(params) {
         token: account.token,
         deviceId: reportDeviceId,
         pluginVersion,
+        agentVersion,
         authenticated: true,
         log,
     });
-    // §A.0 — fallback expiry source. Prefer the SQLite `activated_at`; null when
-    // the credentials came from config (no activation row yet) — in that case the
-    // refresh manager relies on the JWT `exp` alone.
+    // §A.0 — fallback expiry source. Prefer the SQLite `activated_at`; null for a
+    // configured start even though the seed block above may have just created a
+    // row — this cell only ever queries `store.getActivationCredentials` when
+    // `source === "sqlite"`, so a config-sourced account relies on the JWT `exp`
+    // alone until its next SQLite-first resolution.
     let activatedAtMs = activationAccount.source === "sqlite" && store?.getActivationCredentials
         ? store.getActivationCredentials({ platform: "openclaw", accountId })?.activatedAt ?? null
         : null;
@@ -872,16 +904,16 @@ export async function startOpenclawClawlingGateway(params) {
         getAccessToken: () => account.token,
         getRefreshToken: () => latestRefreshToken,
         persistRotatedTokens: async (tokens) => {
-            // §0 — persist to BOTH stores BEFORE the in-memory swap. A failure in
-            // EITHER store must REJECT so the manager skips the in-memory swap and
-            // treats the refresh as transient (keep the current tokens, back off). Do
-            // NOT swallow the SQLite write error: `rotateActivationTokens` returns
-            // `null` when its internal `write()` caught an exception (a real write
-            // failure), `false` only when no activation row exists yet (config-sourced
-            // agent — legitimately nothing to update). A swallowed write failure must
-            // not leave the SQLite row holding the now-dead refresh token while the
-            // in-memory token is rotated, which would brick a sqlite-sourced agent on
-            // restart.
+            // §0 — persist durably BEFORE the in-memory swap. SQLite is the
+            // startup credential source of truth: when a store is available its
+            // write must succeed or the refresh stays transient (no swap, keep
+            // current tokens, back off). A 0-row UPDATE (`false`) means the
+            // activations row is missing (e.g. cleared out-of-band) rather than a
+            // write failure — self-heal by re-seeding it from the in-memory
+            // identity with the ROTATED pair (mirrors Hermes's seed-on-rotate
+            // §C.2 semantics), then continue exactly as on success. `null` is a
+            // caught write exception and stays transient — that's a real failure,
+            // not a missing row.
             if (store?.rotateActivationTokens) {
                 const rotateResult = store.rotateActivationTokens({
                     platform: "openclaw",
@@ -889,12 +921,42 @@ export async function startOpenclawClawlingGateway(params) {
                     accessToken: tokens.accessToken,
                     refreshToken: tokens.refreshToken,
                 });
-                if (rotateResult === null) {
+                if (rotateResult === false) {
+                    if (!store.upsertActivation) {
+                        throw new Error("clawchat-plugin-openclaw sqlite rotate activation tokens failed");
+                    }
+                    try {
+                        store.upsertActivation({
+                            platform: "openclaw",
+                            accountId,
+                            userId: account.userId,
+                            ownerUserId: account.ownerUserId,
+                            accessToken: tokens.accessToken,
+                            refreshToken: tokens.refreshToken,
+                            loginMethod: "config-seed",
+                            deviceId: refreshDeviceId,
+                        });
+                    }
+                    catch {
+                        throw new Error("clawchat-plugin-openclaw sqlite rotate activation tokens failed");
+                    }
+                }
+                else if (rotateResult === null) {
                     throw new Error("clawchat-plugin-openclaw sqlite rotate activation tokens failed");
                 }
+                // Channel config is a human-readable mirror once SQLite holds the
+                // pair — sync best-effort, never fail the refresh over it.
+                try {
+                    await persistConfigTokens(tokens);
+                }
+                catch (error) {
+                    log?.error?.(`[${accountId}] clawchat-plugin-openclaw config token mirror failed (sqlite already rotated): ${error instanceof Error ? error.message : String(error)}`);
+                }
+                return;
             }
-            // A config write failure rejects out of `mutateConfigFile` and propagates
-            // here, which is what we want — persistence incomplete ⇒ no swap.
+            // No SQLite store available — channel config is the only durable
+            // store, so its write failure must reject and keep the refresh
+            // transient (pre-existing behavior for store-less test transports).
             await persistConfigTokens(tokens);
         },
         swapInMemoryTokens: (tokens) => {
@@ -1762,6 +1824,10 @@ export async function startOpenclawClawlingGateway(params) {
     // 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`).
+    // Update detection converges on raw sha256 (readLocalSkillState), not the
+    // frontmatter version, so a same-version content fix still applies; a
+    // manifest `removed` id tombstones the LOCAL managed copy (never bundled)
+    // via removeManagedSkill, deleting only ids the official manifest names.
     const skillUpdateConsent = new PendingConsentStore();
     const managedSkillsDir = resolveManagedSkillsDir();
     let bundledSkillsDir = null;
@@ -1805,10 +1871,10 @@ export async function startOpenclawClawlingGateway(params) {
             return;
         }
         // Effective current = managed copy if present, else bundled (host precedence).
-        const localVersions = await readEffectiveSkillVersions(managedSkillsDir, bundledSkillsDir);
         await runSkillUpdateCheck({
             ownerUserId,
-            localVersions,
+            readLocalState: (id) => readLocalSkillState(managedSkillsDir, bundledSkillsDir, id),
+            hasManagedSkill: (id) => managedSkillExists(managedSkillsDir, id),
             fetchFn: globalThis.fetch,
             store: skillUpdateConsent,
             sendOwnerMessage: sendOwnerSkillMessage,

package/dist/src/skill-update.js

@@ -29,8 +29,12 @@ import { fileURLToPath } from "node:url";
  *   implementation in `@clawling/clawchat-plugin-install-cli`
  *   (`packages/core/src/skills/check-update.ts`). That package is
  *   workspace-private, so the logic is duplicated here rather than imported.
- * - Strict semver compare mirrors the reference `parseComparableVersion`
- *   (`X.Y[.Z[.W]][-buildnum]`).
+ * - Update detection converges on raw sha256 comparison: ANY byte difference
+ *   from the official source (or a missing local file) is an update —
+ *   upgrade, rollback, or same-version content fix alike. The strict semver
+ *   compare (`parseComparableVersion` / `isVersionOlder`, still ported from
+ *   the reference `parseComparableVersion`, `X.Y[.Z[.W]][-buildnum]`) is kept
+ *   only for consent-prompt display wording, not for the `hasUpdate` decision.
  * - All network IO goes through an injected `FetchLike`; tests never touch the
  *   real network.
  *
@@ -151,7 +155,25 @@ export function parseSkillsManifest(text) {
             skills[target][skillId] = asEntry(entry, `${target}.${skillId}`);
         }
     }
-    return { schema: 1, skills };
+    const removed = {};
+    if (data.removed !== undefined) {
+        if (!data.removed || typeof data.removed !== "object" || Array.isArray(data.removed)) {
+            throw new Error("skills manifest `removed` must be an object");
+        }
+        for (const [target, ids] of Object.entries(data.removed)) {
+            if (!Array.isArray(ids) || !ids.every((i) => typeof i === "string" && i.trim())) {
+                throw new Error(`skills manifest removed[${target}] must be a list of skill ids`);
+            }
+            const cleaned = ids.map((i) => i.trim());
+            for (const id of cleaned) {
+                if (skills[target]?.[id]) {
+                    throw new Error(`skill ${target}.${id} is in both skills and removed`);
+                }
+            }
+            removed[target] = cleaned;
+        }
+    }
+    return { schema: 1, skills, removed };
 }
 async function fetchText(url, fetchFn) {
     let response;
@@ -167,9 +189,10 @@ async function fetchText(url, fetchFn) {
     return response.text();
 }
 /**
- * Read the official manifest for the `openclaw` target and compare each skill's
- * offered version against the locally installed `current` map. A skill missing
- * from `current` is reported as `hasUpdate: true`.
+ * Read the official manifest for the `openclaw` target and compare each
+ * skill's offered content (sha256) against its effective local state, read
+ * on demand via `readLocalState`. Any sha256 mismatch — or no local state at
+ * all — is reported as `hasUpdate: true`.
  */
 export async function checkSkillUpdate(options) {
     const ref = options.ref ?? DEFAULT_SKILLS_REF;
@@ -181,11 +204,14 @@ export async function checkSkillUpdate(options) {
     }
     const results = [];
     for (const [skillId, entry] of Object.entries(targetSkills)) {
-        const current = options.current[skillId] ?? null;
-        const hasUpdate = current === null ? true : isVersionOlder(current, entry.version);
+        const state = await options.readLocalState(skillId);
+        // sha convergence: any byte difference from the official source (or a
+        // missing local file) is an update — upgrade, rollback, or same-version
+        // content fix alike.
+        const hasUpdate = !state || state.sha256 !== entry.sha256;
         results.push({
             skillId,
-            current,
+            current: state?.version ?? null,
             latest: entry.version,
             hasUpdate,
             path: entry.path,
@@ -193,7 +219,12 @@ export async function checkSkillUpdate(options) {
             bytes: entry.bytes,
         });
     }
-    return { ref, results, hasUpdate: results.some((r) => r.hasUpdate) };
+    return {
+        ref,
+        results,
+        hasUpdate: results.some((r) => r.hasUpdate),
+        removedIds: manifest.removed[SKILL_TARGET] ?? [],
+    };
 }
 /**
  * Download one skill markdown file and integrity-check it against the manifest
@@ -230,52 +261,41 @@ export function parseSkillFrontmatterVersion(markdown) {
     const raw = (versionLine[1] ?? "").trim().replace(/^["']|["']$/g, "");
     return raw || null;
 }
-/** Read one skill's frontmatter `version` from `<dir>/<skillId>/SKILL.md`. */
-async function readSingleSkillVersion(dir, skillId) {
+async function readSkillStateFromDir(dir, skillId) {
     try {
-        const md = await fs.readFile(path.join(dir, skillId, "SKILL.md"), "utf8");
-        return parseSkillFrontmatterVersion(md);
+        const buf = await fs.readFile(path.join(dir, skillId, "SKILL.md"));
+        return {
+            version: parseSkillFrontmatterVersion(buf.toString("utf8")),
+            sha256: crypto.createHash("sha256").update(buf).digest("hex"),
+        };
     }
     catch {
-        return null; // missing / unreadable
+        return null;
     }
 }
 /**
- * Read the installed version of each requested skill from a SINGLE directory
- * (`<skillsDir>/<skillId>/SKILL.md`). Missing files / missing frontmatter
- * version are simply omitted (treated as "not installed" → update available).
+ * Effective local state of ONE skill, mirroring the host's managed-over-bundled
+ * precedence: managed copy if present, else bundled, else null. Called per
+ * remote manifest entry so dynamically delivered extra skills are hashed too
+ * (a static bundled-id list would misreport extras as never-installed).
  */
-export async function readLocalSkillVersions(skillsDir, skillIds = OPENCLAW_SKILL_IDS) {
-    const versions = {};
-    for (const skillId of skillIds) {
-        const version = await readSingleSkillVersion(skillsDir, skillId);
-        if (version)
-            versions[skillId] = version;
-    }
-    return versions;
+export async function readLocalSkillState(managedDir, bundledDir, skillId) {
+    const managed = await readSkillStateFromDir(managedDir, skillId);
+    if (managed)
+        return managed;
+    if (bundledDir)
+        return readSkillStateFromDir(bundledDir, skillId);
+    return null;
 }
-/**
- * Read the EFFECTIVE installed version of each skill, mirroring the host's
- * managed-over-bundled precedence (`src/skills/loading/workspace.ts:1220-1239`,
- * managed=3 > bundled=2): use the managed copy's frontmatter `version` when
- * `<managedDir>/<id>/SKILL.md` exists, otherwise fall back to the bundled
- * copy's. A skill present in neither is omitted (→ update available).
- */
-export async function readEffectiveSkillVersions(managedDir, bundledDir, skillIds = OPENCLAW_SKILL_IDS) {
-    const versions = {};
-    for (const skillId of skillIds) {
-        const managed = await readSingleSkillVersion(managedDir, skillId);
-        if (managed) {
-            versions[skillId] = managed;
-            continue;
-        }
-        if (bundledDir) {
-            const bundled = await readSingleSkillVersion(bundledDir, skillId);
-            if (bundled)
-                versions[skillId] = bundled;
-        }
+/** True when `<managedDir>/<skillId>/SKILL.md` exists (removal precondition). */
+export async function managedSkillExists(managedDir, skillId) {
+    try {
+        await fs.access(path.join(managedDir, skillId, "SKILL.md"));
+        return true;
+    }
+    catch {
+        return false;
     }
-    return versions;
 }
 /**
  * Resolve OpenClaw's state directory, mirroring the host `src/utils.ts:132-154`:
@@ -359,6 +379,18 @@ export async function atomicWriteSkill(skillsDir, skillId, content) {
         throw err;
     }
 }
+/**
+ * Delete a tombstoned managed skill: remove `<skillsDir>/<skillId>/SKILL.md`
+ * (the host chokidar-watches the dir; the unlink triggers a snapshot rebuild
+ * that drops the registration) and best-effort remove the now-empty dir.
+ * Deletion is the ONE legitimate delete of a skill path, and ONLY for ids the
+ * official manifest explicitly tombstones. Idempotent.
+ */
+export async function removeManagedSkill(skillsDir, skillId) {
+    const dir = path.join(skillsDir, skillId);
+    await fs.rm(path.join(dir, "SKILL.md"), { force: true });
+    await fs.rmdir(dir).catch(() => { });
+}
 const AFFIRM_TOKENS = new Set([
     "更新",
     "更新吧",
@@ -438,7 +470,20 @@ export class PendingConsentStore {
     }
 }
 function describeUpdate(u) {
-    return `「${u.skillId}」v${u.current ?? "无"} → v${u.target}`;
+    if (u.current === null)
+        return `「${u.skillId}」v无 → v${u.target}`;
+    let cmp = -1;
+    try {
+        cmp = compareVersions(u.current, u.target);
+    }
+    catch {
+        cmp = -1; // unparsable local version — show as a plain update
+    }
+    if (cmp === 0)
+        return `「${u.skillId}」v${u.target}(内容修订)`;
+    if (cmp > 0)
+        return `「${u.skillId}」v${u.current} → v${u.target}(回滚)`;
+    return `「${u.skillId}」v${u.current} → v${u.target}`;
 }
 /**
  * Step ③–⑤ (plan §2): on `clawchat.skill.update.check`, check the official
@@ -453,23 +498,25 @@ export async function runSkillUpdateCheck(options) {
         return null;
     }
     const outcome = await checkSkillUpdate({
-        current: options.localVersions,
+        readLocalState: options.readLocalState,
         ...(options.ref ? { ref: options.ref } : {}),
         ...(options.base ? { base: options.base } : {}),
         fetchFn: options.fetchFn,
     });
     const updates = outcome.results
         .filter((r) => r.hasUpdate)
-        .map((r) => ({
-        skillId: r.skillId,
-        current: r.current,
-        target: r.latest,
-        path: r.path,
-        sha256: r.sha256,
-        bytes: r.bytes,
-    }));
-    if (updates.length === 0) {
-        options.log?.info?.("clawchat skill-update check: no updates available");
+        .map((r) => ({ skillId: r.skillId, current: r.current, target: r.latest, path: r.path, sha256: r.sha256, bytes: r.bytes }));
+    const removals = [];
+    for (const skillId of outcome.removedIds) {
+        if (OPENCLAW_SKILL_IDS.includes(skillId)) {
+            options.log?.info?.(`clawchat skill-update: ignoring tombstone for bundled skill ${skillId}`);
+            continue;
+        }
+        if (await options.hasManagedSkill(skillId))
+            removals.push({ skillId });
+    }
+    if (updates.length === 0 && removals.length === 0) {
+        options.log?.info?.("clawchat skill-update check: nothing to converge");
         return null;
     }
     const now = (options.now ?? Date.now)();
@@ -478,13 +525,19 @@ export async function runSkillUpdateCheck(options) {
         ref: outcome.ref,
         ...(options.base ? { base: options.base } : {}),
         updates,
+        removals,
         createdAt: now,
         expiresAt: now + (options.timeoutMs ?? DEFAULT_CONSENT_TIMEOUT_MS),
     };
     options.store.set(record);
-    const text = `我的技能有更新:${updates.map(describeUpdate).join(";")}。回复「更新」确认,「取消」忽略。`;
+    const segments = [];
+    if (updates.length > 0)
+        segments.push(`我的技能有更新:${updates.map(describeUpdate).join(";")}`);
+    if (removals.length > 0)
+        segments.push(`以下技能将下线移除:${removals.map((r) => `「${r.skillId}」`).join("、")}`);
+    const text = `${segments.join(";")}。回复「更新」确认,「取消」忽略。`;
     await options.sendOwnerMessage(text);
-    options.log?.info?.(`clawchat skill-update check: asked owner for consent on ${updates.map((u) => u.skillId).join(",")}`);
+    options.log?.info?.(`clawchat skill-update check: asked owner for consent on updates=[${updates.map((u) => u.skillId).join(",")}] removals=[${removals.map((r) => r.skillId).join(",")}]`);
     return record;
 }
 /**
@@ -516,22 +569,23 @@ export async function handleOwnerConsentReply(options) {
         return true;
     }
     // verdict === "affirm"
-    const readLocalVersion = options.readLocalVersion ??
+    const readLocalSha = options.readLocalSha ??
         (async (skillId) => {
             try {
-                const md = await fs.readFile(path.join(options.skillsDir, skillId, "SKILL.md"), "utf8");
-                return parseSkillFrontmatterVersion(md);
+                const buf = await fs.readFile(path.join(options.skillsDir, skillId, "SKILL.md"));
+                return crypto.createHash("sha256").update(buf).digest("hex");
             }
             catch {
                 return null;
             }
         });
     const applied = [];
+    const removed = [];
     try {
         for (const update of pending.updates) {
-            // Idempotency: skip a skill already at the target version on disk.
-            const onDisk = await readLocalVersion(update.skillId);
-            if (onDisk === update.target) {
+            // Idempotency: skip a skill whose on-disk bytes already match the target.
+            const onDisk = await readLocalSha(update.skillId);
+            if (onDisk === update.sha256) {
                 applied.push(update);
                 continue;
             }
@@ -544,6 +598,18 @@ export async function handleOwnerConsentReply(options) {
             applied.push(update);
             options.log?.info?.(`clawchat skill-update: applied ${update.skillId} -> v${update.target} (atomic overwrite)`);
         }
+        for (const removal of pending.removals) {
+            // Defensive re-guard: bundled skills must never be deleted, even though
+            // runSkillUpdateCheck already filters them out of removal candidates.
+            // Unreachable in the normal flow; kept as a cheap safety net.
+            if (OPENCLAW_SKILL_IDS.includes(removal.skillId)) {
+                options.log?.info?.(`clawchat skill-update: skipped removal of bundled skill ${removal.skillId} (defensive re-guard)`);
+                continue;
+            }
+            await removeManagedSkill(options.skillsDir, removal.skillId);
+            removed.push(removal);
+            options.log?.info?.(`clawchat skill-update: removed tombstoned skill ${removal.skillId}`);
+        }
     }
     catch (err) {
         // Keep the pending record so the owner can retry with another "更新"; report
@@ -553,7 +619,11 @@ export async function handleOwnerConsentReply(options) {
         return true;
     }
     options.store.clear();
-    const summary = applied.map((u) => `「${u.skillId}」v${u.target}`).join("、");
-    await options.sendOwnerMessage(`✅ 已更新到 ${summary}`);
+    const segments = [];
+    if (applied.length > 0)
+        segments.push(`已更新到 ${applied.map((u) => `「${u.skillId}」v${u.target}`).join("、")}`);
+    if (removed.length > 0)
+        segments.push(`已移除 ${removed.map((r) => `「${r.skillId}」`).join("、")}`);
+    await options.sendOwnerMessage(`✅ ${segments.join(";")}`);
     return true;
 }