openclaw-lark-multi-agent 1.7.0 → 1.8.1

package/dist/compact-progress.d.ts

@@ -1,5 +1,5 @@
 /** Coarse phase of the compaction flow, drives the card's primary line. */
-export type CompactPhase = "native" | "transcript-trim" | "trim";
+export type CompactPhase = "native" | "transcript-trim" | "trim" | "tooltrim";
 /** Terminal outcome used by the renderer to pick color/emoji. */
 export type CompactState = "running" | "done" | "failed" | "noop";
 /** Structured snapshot the renderer turns into a Feishu interactive card. */
@@ -52,6 +52,8 @@ export declare class CompactProgressController {
     start(): void;
     /** Switch straight into explicit transcript-trim mode (user-requested trim). */
     toTrim(): void;
+    /** Switch into ToolTrim mode (keep text, filter tool payload). */
+    toToolTrim(): void;
     /** Native compaction gave up; switch to Gateway-owned transcript-tail trim. */
     toTranscriptTrim(): Promise<void>;
     /** Finished successfully; patch the card to the done state with a detail line. */

package/dist/compact-progress.js

@@ -47,10 +47,16 @@ export class CompactProgressController {
     }
     /** Switch straight into explicit transcript-trim mode (user-requested trim). */
     toTrim() {
-        if (this.finalized || this.phase === "trim" || this.phase === "transcript-trim")
+        if (this.finalized || this.phase === "trim" || this.phase === "transcript-trim" || this.phase === "tooltrim")
             return;
         this.phase = "trim";
     }
+    /** Switch into ToolTrim mode (keep text, filter tool payload). */
+    toToolTrim() {
+        if (this.finalized || this.phase === "tooltrim" || this.phase === "transcript-trim")
+            return;
+        this.phase = "tooltrim";
+    }
     /** Native compaction gave up; switch to Gateway-owned transcript-tail trim. */
     async toTranscriptTrim() {
         if (this.finalized || this.phase === "transcript-trim")

package/dist/feishu-bot.d.ts

@@ -137,6 +137,14 @@ export declare class FeishuBot {
     /** Fire and clear run-failure observers for a chat (isolated callbacks). */
     private fireRunFailureObservers;
     private processQueue;
+    /**
+     * Force-release a stuck queue owner after the gateway authoritatively
+     * reported the session idle (no active run). The zombie owner's deep waits
+     * can otherwise hold chat custody forever: completion events routed through
+     * the proactive path are invisible to them. Steer-fallback triggers are
+     * restored via the failure observers so their input drains normally.
+     */
+    private forceExpireQueueOwner;
     private processQueueInner;
     private shouldHandleBridgeCommand;
     private shouldRespond;

package/dist/feishu-bot.js

@@ -886,7 +886,7 @@ export class FeishuBot {
                         `━━━━━━━━━━━━━━━━━━`,
                         `桥接层命令（单斜杠，由 openclaw-lark-multi-agent 本地处理）`,
                         `📊 /status  — 查看当前模型、Token 用量、Session 状态`,
-                        `🧹 /compact [N|maxLines=N|semantic] — 裁剪转录尾部（默认，保留最近事件）；N 指定保留条数；semantic 走 LLM 总结`,
+                        `🧹 /compact — 默认 ToolTrim：保文本、过滤工具载荷（保留最近 10 条）；/compact semantic 走 LLM 总结；/compact trim 或 N 裁剪转录尾部`,
                         `🔄 /reset   — 重置当前 bot 的 OpenClaw session`,
                         `⏹️ /stop    — 强制停止当前 bot 在本聊天的卡死 run，解锁队列`,
                         `🔊 /verbose — 开关当前聊天里的 Tool Call 显示`,
@@ -1286,7 +1286,39 @@ export class FeishuBot {
                 stopWatchingConsumption();
                 if ("cancelPending" in steer)
                     steer.cancelPending?.();
-                console.log(`[${this.config.name}] Agent busy for ${chatId.slice(-8)} (steer=${steer.status}), queuing: "${cleanText.substring(0, 50)}..."`);
+                // Zombie-owner detection (2026-10-15 guangzi incident): steer found no
+                // active run while our in-memory owner still holds the chat. Ask the
+                // gateway for the authoritative session status: if it is idle, the owner
+                // is a zombie (its completion event was routed through the proactive
+                // path and it will never settle). Force-expire it and process this input
+                // NOW instead of queueing behind a dead promise forever.
+                if (steer.status === "no_active_run" && this.queueRuns.has(chatId)) {
+                    const live = await this.openclawClient.getSessionRuntimeStatus(sessionKeyForSteer).catch(() => null);
+                    if (live && !live.running) {
+                        console.warn(`[${this.config.name}] gateway reports session idle while queue owner exists for ${chatId.slice(-8)} — expiring zombie owner (status=${live.status})`);
+                        this.forceExpireQueueOwner(chatId, `gateway idle (steer=${steer.status}, session=${live.status})`);
+                        // Fall through to the normal send path below; the durable trigger
+                        // for this input is still set, so the fresh processQueue drains it.
+                    }
+                    else {
+                        console.log(`[${this.config.name}] Agent busy for ${chatId.slice(-8)} (steer=${steer.status}, session running=${live?.running}), queuing: "${cleanText.substring(0, 50)}..."`);
+                    }
+                }
+                else {
+                    console.log(`[${this.config.name}] Agent busy for ${chatId.slice(-8)} (steer=${steer.status}), queuing: "${cleanText.substring(0, 50)}..."`);
+                }
+                if (!this.queueRuns.has(chatId)) {
+                    // Owner gone (force-expired or settled during the steer RPC): send now.
+                    await this.removeReaction(messageId, "Typing").catch(() => { });
+                    await this.addReaction(messageId, "Get").catch(() => { });
+                    const acksNow = this.pendingAckMessages.get(chatId) || [];
+                    for (const a of acksNow)
+                        if (a.messageId === messageId)
+                            a.emoji = "Get";
+                    this.pendingAckMessages.set(chatId, acksNow);
+                    await this.processQueue(chatId);
+                    return;
+                }
                 // Reconciliation may have finished the old owner during the steer RPC.
                 // Ensure this new, still-pending input is drained even when that owner
                 // exited through an error path. Already-consumed input is never replayed.
@@ -1437,13 +1469,36 @@ export class FeishuBot {
             return existing;
         }
         const run = this.processQueueInner(chatId).finally(() => {
-            this.queueRuns.delete(chatId);
-            this.runFailureObservers.delete(chatId);
-            this.admittedSteerAcks.delete(chatId);
+            // Ownership token guard: only the CURRENT owner may release the slot. A
+            // zombie owner that settles after forceExpireQueueOwner must not delete
+            // the replacement owner's entry (that would open a concurrent-run window).
+            if (this.queueRuns.get(chatId) === run) {
+                this.queueRuns.delete(chatId);
+                this.runFailureObservers.delete(chatId);
+                this.admittedSteerAcks.delete(chatId);
+            }
         });
         this.queueRuns.set(chatId, run);
         return run;
     }
+    /**
+     * Force-release a stuck queue owner after the gateway authoritatively
+     * reported the session idle (no active run). The zombie owner's deep waits
+     * can otherwise hold chat custody forever: completion events routed through
+     * the proactive path are invisible to them. Steer-fallback triggers are
+     * restored via the failure observers so their input drains normally.
+     */
+    forceExpireQueueOwner(chatId, reason) {
+        const owner = this.queueRuns.get(chatId);
+        if (!owner)
+            return false;
+        console.warn(`[${this.config.name}] force-expiring zombie queue owner for ${chatId.slice(-8)}: ${reason}`);
+        this.queueRuns.delete(chatId);
+        this.fireRunFailureObservers(chatId);
+        this.runFailureObservers.delete(chatId);
+        this.admittedSteerAcks.delete(chatId);
+        return true;
+    }
     async processQueueInner(chatId) {
         while (true) {
             // A fresh batch starts: steered inputs admitted into the PREVIOUS batch
@@ -3422,9 +3477,11 @@ export class FeishuBot {
         // Running: phase line + ticking elapsed footer.
         const phaseLine = view.phase === "transcript-trim"
             ? (en ? "🧹 Semantic compaction unavailable — trimming transcript safely…" : "🧹 语义压缩不可用，正在安全裁剪转录…")
-            : view.phase === "trim"
-                ? (en ? "🧹 Trimming transcript tail (keeping the most recent events)…" : "🧹 正在裁剪转录尾部（保留最近的事件）…")
-                : (en ? "🧹 Compacting session…" : "🧹 正在压缩 session…");
+            : view.phase === "tooltrim"
+                ? (en ? "🧹 ToolTrim: keeping text, filtering tool payload (last 10 tool calls kept)…" : "🧹 ToolTrim 压缩：保留文本，过滤工具载荷（保留最近 10 条工具调用）…")
+                : view.phase === "trim"
+                    ? (en ? "🧹 Trimming transcript tail (keeping the most recent events)…" : "🧹 正在裁剪转录尾部（保留最近的事件）…")
+                    : (en ? "🧹 Compacting session…" : "🧹 正在压缩 session…");
         const footer = en ? `⏱ ${view.elapsed}` : `⏱ 已用 ${view.elapsed}`;
         return {
             schema: "2.0",
@@ -4319,7 +4376,25 @@ export class FeishuBot {
      *     a trim so the session is still reclaimed.
      */
     async compactWithFallback(sessionKey, onPhase, opts = {}) {
-        const mode = opts.mode === "semantic" ? "semantic" : "trim";
+        const mode = opts.mode === "trim" ? "trim" : opts.mode === "semantic" ? "semantic" : "tooltrim";
+        if (mode === "tooltrim") {
+            onPhase?.("tooltrim");
+            try {
+                const res = await this.openclawClient.toolTrimCompact(sessionKey, 10);
+                if (res?.compacted === true) {
+                    return {
+                        compacted: true,
+                        method: "tooltrim",
+                        detail: typeof res?.detail === "string" ? res.detail : "文本保留；仅保留最近 10 条工具调用",
+                    };
+                }
+                const reason = typeof res?.detail === "string" ? res.detail : typeof res?.reason === "string" ? res.reason : undefined;
+                return { compacted: false, method: "none", reason: reason || "tooltrim made no change" };
+            }
+            catch (err) {
+                return { compacted: false, method: "none", reason: err.message };
+            }
+        }
         const trimMaxLines = Number.isFinite(opts.maxLines) && opts.maxLines >= 20
             ? Math.floor(opts.maxLines)
             : compactFallbackMaxLines();
@@ -4341,7 +4416,7 @@ export class FeishuBot {
         // semantic mode: LLM summarize first, trim as fallback.
         let nativeReason;
         try {
-            const res = await this.openclawClient.compactSession(sessionKey);
+            const res = await this.openclawClient.semanticCompact(sessionKey);
             if (res?.compacted === true)
                 return { compacted: true, method: "native" };
             nativeReason = typeof res?.reason === "string" ? res.reason : undefined;
@@ -4387,7 +4462,10 @@ export class FeishuBot {
         //   /compact 500             → tail trim keeping the last 500 events
         //   /compact maxLines=500    → same as above
         const argTokens = args.split(/\s+/).filter(Boolean);
-        let mode = "trim";
+        // toolTrim is the default (user directive 2026-10-10): bare /compact keeps
+        // text and filters tool payload. Explicit tokens: semantic (LLM summarize),
+        // trim/tail or a bare number N (mechanical tail trim keeping N events).
+        let mode = "tooltrim";
         let maxLines;
         for (const tok of argTokens) {
             const semanticMatch = /^(semantic|summarize|llm)$/i.exec(tok);
@@ -4395,9 +4473,20 @@ export class FeishuBot {
                 mode = "semantic";
                 continue;
             }
+            const toolTrimMatch = /^(tooltrim|tool_trim|tool-trim)$/i.exec(tok);
+            if (toolTrimMatch) {
+                mode = "tooltrim";
+                continue;
+            }
+            const trimMatch = /^(trim|tail)$/i.exec(tok);
+            if (trimMatch) {
+                mode = "trim";
+                continue;
+            }
             const linesMatch = /^(?:maxlines|max_lines)[=:](\d{2,})$/i.exec(tok) || /^(\d{2,})$/.exec(tok);
             if (linesMatch) {
                 maxLines = Number(linesMatch[1] || linesMatch[2]);
+                mode = "trim";
                 continue;
             }
         }
@@ -4408,6 +4497,8 @@ export class FeishuBot {
         }, { locale: en ? "en" : "zh" });
         if (mode === "trim")
             progress.toTrim();
+        else if (mode === "tooltrim")
+            progress.toToolTrim();
         progress.start();
         try {
             const r = await this.compactWithFallback(sessionKey, (phase) => {
@@ -4420,16 +4511,22 @@ export class FeishuBot {
                 const localizedTrimDetail = r.detail
                     ?.replace("kept ", en ? "kept " : "保留最近 ")
                     .replace(" transcript events", en ? " transcript events" : " 条转录事件");
-                const detail = r.method === "transcript-trim" && localizedTrimDetail
-                    ? (en ? `transcript trim: ${localizedTrimDetail}` : `转录裁剪：${localizedTrimDetail}`)
-                    : (en ? "native" : "原生压缩");
+                const detail = r.method === "tooltrim"
+                    ? (en ? `tooltrim: ${r.detail || "text kept; tool payload filtered"}` : `ToolTrim：${r.detail || "文本保留，工具载荷已过滤"}`)
+                    : r.method === "transcript-trim" && localizedTrimDetail
+                        ? (en ? `transcript trim: ${localizedTrimDetail}` : `转录裁剪：${localizedTrimDetail}`)
+                        : (en ? "native" : "原生压缩");
                 await progress.done(detail);
                 if (!progress.id) {
-                    await this.replyMessage(messageId, r.method === "transcript-trim"
+                    await this.replyMessage(messageId, r.method === "tooltrim"
                         ? (en
-                            ? `✅ Session compacted (transcript trim${localizedTrimDetail ? ": " + localizedTrimDetail : ""})`
-                            : `✅ Session 已压缩（转录裁剪${localizedTrimDetail ? "：" + localizedTrimDetail : ""}）`)
-                        : (en ? `✅ Session compacted` : `✅ Session 已压缩`));
+                            ? `✅ Session compacted (tooltrim${r.detail ? `: ${r.detail}` : ""})`
+                            : `✅ Session 已压缩（ToolTrim${r.detail ? `：${r.detail}` : ""}）`)
+                        : r.method === "transcript-trim"
+                            ? (en
+                                ? `✅ Session compacted (transcript trim${localizedTrimDetail ? ": " + localizedTrimDetail : ""})`
+                                : `✅ Session 已压缩（转录裁剪${localizedTrimDetail ? "：" + localizedTrimDetail : ""}）`)
+                            : (en ? `✅ Session compacted` : `✅ Session 已压缩`));
                 }
             }
             else {

package/dist/openclaw-client.d.ts

@@ -178,7 +178,7 @@ export declare class OpenClawClient {
      * the ambiguous public admission as a realtime-insertion success signal.
      */
     steer(sessionKey: string, text: string, displayText?: string): Promise<{
-        status: "steered" | "unavailable";
+        status: "steered" | "unavailable" | "no_active_run";
         runId?: string;
         /** Cancel provisional transcript correlation when LMA falls back to a normal run. */
         cancelPending?: () => void;
@@ -219,6 +219,16 @@ export declare class OpenClawClient {
     ensureModel(sessionKey: string, expectedModel: string): Promise<boolean>;
     deleteSession(key: string, deleteTranscript?: boolean): Promise<any>;
     resetSession(key: string): Promise<any>;
+    /** One-shot ToolTrim compaction: route the native semantic compaction
+     *  through the lma-core plugin's lma-tooltrim provider (keep text, keep only
+     *  the 10 most recent tool calls, drop the rest of the tool payload).
+     *  Orchestration (validated E2E 2026-10-10): config.set {raw, baseHash} →
+     *  sessions.compact → restore the original config (always). */
+    toolTrimCompact(key: string, keepRecentToolCalls?: number): Promise<any>;
+    /** Explicit LLM-summarize compaction (/compact semantic). Since lma-tooltrim
+     *  is the persistent default provider, temporarily unset it so the built-in
+     *  summarization pipeline runs, then restore the original config (always). */
+    semanticCompact(key: string): Promise<any>;
     compactSession(key: string, options?: {
         maxLines?: number;
     }): Promise<any>;

package/dist/openclaw-client.js

@@ -1628,6 +1628,10 @@ export class OpenClawClient {
                     console.warn(`[OpenClaw] lma.steer ${res.status} for ${key.slice(-8)}`);
                 }
                 cancelPending();
+                // Pass the gateway's authoritative "no active run" verdict through: the
+                // caller uses it to detect a zombie queue owner (2026-10-15 incident).
+                if (res?.status === "no_active_run")
+                    return { status: "no_active_run" };
                 return { status: "unavailable" };
             }
             return { status: "steered", cancelPending };
@@ -1844,6 +1848,117 @@ export class OpenClawClient {
         // sessions.reset may not return a response; use short timeout
         return this.rpc("sessions.reset", { key: this.canonicalSessionKey(key) }, 5000).catch(() => { });
     }
+    /** One-shot ToolTrim compaction: route the native semantic compaction
+     *  through the lma-core plugin's lma-tooltrim provider (keep text, keep only
+     *  the 10 most recent tool calls, drop the rest of the tool payload).
+     *  Orchestration (validated E2E 2026-10-10): config.set {raw, baseHash} →
+     *  sessions.compact → restore the original config (always). */
+    async toolTrimCompact(key, keepRecentToolCalls = 10) {
+        const release = await this.acquireMaintenanceSlot("tooltrim");
+        const startedAt = Date.now();
+        const PROVIDER = "lma-tooltrim";
+        let restoreInfo = null;
+        const restoreProvider = async () => {
+            if (!restoreInfo)
+                return;
+            try {
+                await this.rpc("config.set", { raw: restoreInfo.raw, baseHash: restoreInfo.baseHash }, 30000);
+                console.log(`[OpenClaw] tooltrim: compaction provider config restored`);
+            }
+            catch (err) {
+                console.warn(`[OpenClaw] tooltrim: config restore failed:`, err.message);
+            }
+        };
+        try {
+            // 1. Read the full config + its base hash (optimistic-concurrency token).
+            const full = await this.rpc("config.get", {}, 30000);
+            const hash = full?.hash;
+            const cfg = full?.config ?? full?.parsed;
+            if (typeof hash !== "string" || !cfg || typeof cfg !== "object") {
+                return { compacted: false, reason: "无法读取网关配置（config.get）" };
+            }
+            const compNode0 = cfg?.agents?.defaults?.compaction;
+            if (compNode0?.provider !== PROVIDER) {
+                // Provider is not the persistent default: toggle it on for this run and
+                // restore afterwards (portable path for hosts without the default set).
+                const originalRaw = typeof full?.raw === "string" ? full.raw : JSON.stringify(cfg);
+                const agentsNode = (cfg.agents ??= {});
+                const defaultsNode = (agentsNode.defaults ??= {});
+                const comp = (defaultsNode.compaction ??= {});
+                comp.provider = PROVIDER;
+                const setRes = await this.rpc("config.set", { raw: JSON.stringify(cfg), baseHash: hash }, 30000);
+                if (setRes?.ok !== true || typeof setRes?.hash !== "string") {
+                    return { compacted: false, reason: `config.set 失败: ${JSON.stringify(setRes).slice(0, 160)}` };
+                }
+                restoreInfo = { raw: originalRaw, baseHash: setRes.hash };
+            }
+            // 2. Native semantic compaction now routes through our provider.
+            const result = await this.rpc("sessions.compact", { key: this.canonicalSessionKey(key) }, 10 * 60 * 1000);
+            await restoreProvider();
+            const ok = result?.compacted === true;
+            return {
+                compacted: ok,
+                method: "tooltrim",
+                detail: ok
+                    ? `文本保留；工具载荷已过滤（保留最近 ${keepRecentToolCalls} 条工具调用）`
+                    : (typeof result?.reason === "string" ? result.reason : "网关未执行压缩（会话可能正在运行或不需压缩）"),
+                tokensBefore: result?.result?.tokensBefore,
+            };
+        }
+        catch (err) {
+            await restoreProvider();
+            return { compacted: false, method: "tooltrim", reason: err.message };
+        }
+        finally {
+            console.log(`[OpenClaw] tooltrim finished for ${key} in ${Date.now() - startedAt}ms`);
+            release();
+        }
+    }
+    /** Explicit LLM-summarize compaction (/compact semantic). Since lma-tooltrim
+     *  is the persistent default provider, temporarily unset it so the built-in
+     *  summarization pipeline runs, then restore the original config (always). */
+    async semanticCompact(key) {
+        const release = await this.acquireMaintenanceSlot("semantic");
+        const PROVIDER = "lma-tooltrim";
+        let restoreInfo = null;
+        const restoreProvider = async () => {
+            if (!restoreInfo)
+                return;
+            try {
+                await this.rpc("config.set", { raw: restoreInfo.raw, baseHash: restoreInfo.baseHash }, 30000);
+                console.log(`[OpenClaw] semantic: compaction provider config restored`);
+            }
+            catch (err) {
+                console.warn(`[OpenClaw] semantic: config restore failed:`, err.message);
+            }
+        };
+        try {
+            const full = await this.rpc("config.get", {}, 30000);
+            const hash = full?.hash;
+            const cfg = full?.config ?? full?.parsed;
+            const comp = cfg && typeof cfg === "object" ? cfg?.agents?.defaults?.compaction : undefined;
+            if (typeof hash === "string" && cfg && typeof cfg === "object" && comp?.provider) {
+                const originalRaw = typeof full?.raw === "string" ? full.raw : JSON.stringify(cfg);
+                delete comp.provider;
+                const setRes = await this.rpc("config.set", { raw: JSON.stringify(cfg), baseHash: hash }, 30000);
+                if (setRes?.ok === true && typeof setRes?.hash === "string") {
+                    restoreInfo = { raw: originalRaw, baseHash: setRes.hash };
+                }
+                // If the toggle failed we still compact below: routing through the
+                // default provider is a degraded-but-useful outcome vs not compacting.
+            }
+            const result = await this.rpc("sessions.compact", { key: this.canonicalSessionKey(key) }, 10 * 60 * 1000);
+            await restoreProvider();
+            return result;
+        }
+        catch (err) {
+            await restoreProvider();
+            throw err;
+        }
+        finally {
+            release();
+        }
+    }
     async compactSession(key, options = {}) {
         const release = await this.acquireMaintenanceSlot("sessions.compact");
         const startedAt = Date.now();

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "openclaw-lark-multi-agent",
-  "version": "1.7.0",
+  "version": "1.8.1",
   "description": "Multi-bot Lark/Feishu bridge for OpenClaw, with per-bot model routing and isolated sessions",
   "type": "module",
   "scripts": {
-    "build": "tsc && npm run build:steer-plugin && npm run build:go-plugin",
+    "build": "tsc && npm run build:steer-plugin && npm run build:go-plugin && npm run build:core-plugin",
     "build:steer-plugin": "tsc -p plugins/lma-steer/tsconfig.json",
     "start": "node dist/index.js",
     "dev": "tsx src/index.ts",
@@ -12,7 +12,8 @@
     "test:coverage": "vitest run --config tests/normal-flow-offline.config.ts --coverage",
     "prepack": "npm run build",
     "prepublishOnly": "npm test && npm pack --dry-run",
-    "build:go-plugin": "tsc -p plugins/lma-go/tsconfig.json"
+    "build:go-plugin": "tsc -p plugins/lma-go/tsconfig.json",
+    "build:core-plugin": "tsc -p plugins/lma-core/tsconfig.json"
   },
   "dependencies": {
     "@larksuiteoapi/node-sdk": "^1.73.3",
@@ -74,4 +75,4 @@
   "publishConfig": {
     "access": "public"
   }
-}
+}

package/scripts/update-lma-core.sh

@@ -0,0 +1,45 @@
+#!/usr/bin/env bash
+# Update the consolidated lma-core gateway plugin from the LMA repo source.
+#
+# Usage:  bash scripts/update-lma-core.sh          (build + deploy + hot reload)
+#         bash scripts/update-lma-core.sh --check  (verify only, no changes)
+#
+# Requirements: repo at ~/openclaw-lark-multi-agent with the plugin sources
+# under plugins/lma-core/src. The gateway hot-reloads the plugin; no gateway
+# restart is needed for code updates (method names are stable).
+set -euo pipefail
+
+REPO="${LMA_REPO:-$HOME/openclaw-lark-multi-agent}"
+EXT_DIR="$HOME/.openclaw/extensions/lma-core"
+PLUGIN_ID="lma-core"
+
+say() { printf '[update-lma-core] %s\n' "$*"; }
+
+if [[ "${1:-}" == "--check" ]]; then
+  say "verifying deployed plugin health..."
+  openclaw gateway call health 2>/dev/null | grep -o "\"$PLUGIN_ID\"" >/dev/null \
+    && say "OK: $PLUGIN_ID loaded in gateway" || { say "FAIL: $PLUGIN_ID not in loaded list"; exit 1; }
+  openclaw gateway call lma.core.capabilities 2>/dev/null | grep -q '"lma-core"' \
+    && say "OK: lma.core.capabilities responds" || { say "FAIL: capabilities RPC"; exit 1; }
+  say "all checks passed."
+  exit 0
+fi
+
+cd "$REPO"
+say "building plugins/lma-core..."
+npm run build:core-plugin
+
+say "deploying to $EXT_DIR..."
+mkdir -p "$EXT_DIR"
+rm -rf "$EXT_DIR/dist"
+cp -r plugins/lma-core/dist "$EXT_DIR/dist"
+cp plugins/lma-core/openclaw.plugin.json plugins/lma-core/package.json "$EXT_DIR/"
+if [[ -f plugins/lma-core/README.md ]]; then cp plugins/lma-core/README.md "$EXT_DIR/"; fi
+
+say "hot-reloading $PLUGIN_ID..."
+openclaw plugins reload "$PLUGIN_ID"
+
+say "verifying..."
+sleep 1
+bash "$0" --check
+say "done. (rollback: git -C $REPO checkout <prev> && re-run this script)"