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

package/dist/src/reply-dispatcher.js

@@ -6,7 +6,16 @@ import { describeOutboundMediaShortfall, uploadOutboundMedia, } from "./media-ru
 import { mintMessageId, sendOpenclawClawlingText, } from "./outbound.js";
 import { isClawChatNoopResponseText } from "./profile-prompt.js";
 import { consumeTerminalClawChatSend } from "./terminal-send.js";
+import { createReplyStream } from "./reply-stream.js";
 import { openclawLlmContextDebug } from "./llm-context-debug.js";
+/**
+ * Re-send cadence for `typing.update {is_typing:true}` while a reply is in
+ * flight: at most half of the client's typing display window (6 s), so a single
+ * lost frame never lets the indicator lapse.
+ */
+export const TYPING_KEEPALIVE_MS = 3_000;
+/** Safety cap for one reply's typing keepalive (15 min). */
+export const TYPING_KEEPALIVE_MAX_MS = 15 * 60_000;
 const GROUP_OWNER_ATTENTION_TITLE = "requires owner attention";
 const APPROVAL_FALLBACK_COMMAND_RE = /(?:^|\s)\/(?:approve|deny)\b/i;
 function ownerAttentionText(groupId, fallbackText) {
@@ -326,6 +335,40 @@ export function createOpenclawClawlingReplyDispatcher(options) {
     const outboundEventType = () => (replyCtx ? "message.reply" : "message.send");
     const outboundRaw = () => ({ target, replyCtx: replyCtx ?? null });
     const terminalSendScopeId = options.terminalSendScopeId ?? null;
+    // ----- Reply streaming (experimental, `streamReplies`) -----------------
+    //
+    // One open stream previews the assistant text being generated. The next
+    // normal materialized send claims it (`message.done` with the final text,
+    // then the final as `message.reply` reusing the stream's message_id, §8.4);
+    // a final that does not extend the preview, a no-reply, a terminal tool
+    // send, or an idle run with nothing delivered fails it. Host partials are snapshots of
+    // the current assistant message that may be rewritten, so a snapshot that no
+    // longer extends the preview fails the old stream and starts a new one.
+    const streamEnabled = account.streamReplies === true;
+    let replyStream = null;
+    const failStream = (reason) => {
+        replyStream?.fail(reason);
+        replyStream = null;
+    };
+    const claimStreamMessageId = (finalText) => {
+        const id = replyStream?.finish(finalText) ?? null;
+        replyStream = null;
+        return id;
+    };
+    const onStreamPartial = (text) => {
+        if (runDone || terminalReplySuppressed)
+            return;
+        if (replyStream?.diverges(text))
+            failStream("superseded");
+        replyStream ??= createReplyStream({
+            client,
+            chatId: target.chatId,
+            mintMessageId,
+            log,
+            logPrefix: `[${account.accountId}] clawchat-plugin-openclaw`,
+        });
+        replyStream.update(text);
+    };
     const consumeTerminalSend = (reason) => {
         if (terminalReplySuppressed)
             return true;
@@ -339,6 +382,7 @@ export function createOpenclawClawlingReplyDispatcher(options) {
         if (!terminal)
             return false;
         terminalReplySuppressed = true;
+        failStream("terminal-send");
         log?.info?.(`[${account.accountId}] clawchat-plugin-openclaw suppressing ${reason} reply after terminal tool send msg=${terminal.messageId} to=${target.chatId}`);
         return true;
     };
@@ -424,7 +468,8 @@ export function createOpenclawClawlingReplyDispatcher(options) {
                 bufferedOutputUrls.push(url);
         }
     };
-    const fullSegmentKey = (text, urls) => JSON.stringify({
+    const fullSegmentKey = (text, urls, mode) => JSON.stringify({
+        mode,
         text: text.replace(/\s+/g, " ").trim(),
         urls: urls.filter(Boolean),
     });
@@ -458,6 +503,39 @@ export function createOpenclawClawlingReplyDispatcher(options) {
             log?.error?.(`[${account.accountId}] clawchat-plugin-openclaw typing update failed: ${String(error)}`);
         }
     };
+    // Plugin-owned typing keepalive. The client lights "typing" for a fixed
+    // window per `is_typing:true` frame, so the sender must re-send at no more
+    // than half that window (TYPING_KEEPALIVE_MS) for as long as the reply is in
+    // flight, and send `false` exactly once at the end. The host's own keepalive
+    // (default 6 s, global config only) equals the client window, so one lost or
+    // late frame makes the indicator flash; we ask the host to turn it off
+    // (`typingKeepalive: false`, honoured by newer hosts) and ignore its repeated
+    // `onReplyStart` ticks on older hosts.
+    let typingTimer = null;
+    let typingCapTimer = null;
+    let typingFinished = false;
+    const stopTyping = () => {
+        if (typingTimer)
+            clearInterval(typingTimer);
+        if (typingCapTimer)
+            clearTimeout(typingCapTimer);
+        typingTimer = null;
+        typingCapTimer = null;
+        typingFinished = true;
+        emitTyping(false);
+    };
+    const startTyping = () => {
+        if (typingFinished || typingTimer)
+            return;
+        emitTyping(true);
+        typingTimer = setInterval(() => emitTyping(true), TYPING_KEEPALIVE_MS);
+        typingTimer.unref?.();
+        typingCapTimer = setTimeout(() => {
+            log?.info?.(`[${account.accountId}] clawchat-plugin-openclaw typing keepalive cap reached; stopping to=${target.chatId}`);
+            stopTyping();
+        }, TYPING_KEEPALIVE_MAX_MS);
+        typingCapTimer.unref?.();
+    };
     const sendOwnerAttention = async (fallbackText, richFragment = null) => {
         const ownerTarget = ownerDirectTarget();
         if (!ownerTarget) {
@@ -479,10 +557,13 @@ export function createOpenclawClawlingReplyDispatcher(options) {
     };
     // ----- Static send ------------------------------------------------------
     const sendStatic = async (text, mediaFragments = [], richFragments = [], options = {}) => {
+        const messageMode = options.messageMode ?? "normal";
         if (isClawChatNoopResponseText(text) &&
             mediaFragments.length === 0 &&
             richFragments.length === 0) {
             log?.info?.(`[${account.accountId}] clawchat-plugin-openclaw outbound suppressed: no-reply token`);
+            if (messageMode === "normal")
+                failStream("no-reply");
             openclawLlmContextDebug.writeSnapshot({
                 visibility: "host_event",
                 trace: {
@@ -506,11 +587,12 @@ export function createOpenclawClawlingReplyDispatcher(options) {
             return null;
         if (consumeTerminalSend("static"))
             return null;
-        log?.info?.(`[${account.accountId}] clawchat-plugin-openclaw sending static text_len=${text.length} media=${mediaFragments.length} rich=${richFragments.length} to=${target.chatId}`);
-        const messageId = mintStaticMessageId();
+        log?.info?.(`[${account.accountId}] clawchat-plugin-openclaw sending static mode=${messageMode} text_len=${text.length} media=${mediaFragments.length} rich=${richFragments.length} to=${target.chatId}`);
+        const streamMessageId = messageMode === "normal" ? claimStreamMessageId(text) : null;
+        const messageId = streamMessageId ?? mintStaticMessageId();
         const raw = { target, replyCtx: replyCtx ?? null, mode: "static" };
         const claimed = options.recordMessage
-            ? claimOutbound(outboundEventType(), messageId, text, raw)
+            ? claimOutbound(streamMessageId ? "message.reply" : outboundEventType(), messageId, text, raw)
             : true;
         if (claimed === false) {
             log?.info?.(`[${account.accountId}] clawchat-plugin-openclaw outbound duplicate skipped msg=${messageId}`);
@@ -529,10 +611,14 @@ export function createOpenclawClawlingReplyDispatcher(options) {
             ...(replyCtx ? { replyCtx } : {}),
             ...(richFragments.length > 0 ? { richFragments } : {}),
             ...(mediaFragments.length > 0 ? { mediaFragments } : {}),
+            ...(messageMode !== "normal" ? { messageMode } : {}),
+            ...(streamMessageId ? { finalizesStream: true } : {}),
             log,
         });
         recordOutboundAck("message", messageId, result);
-        if (result)
+        // Process (thinking) messages are not replies: they must not make a
+        // bootstrap greeting look delivered.
+        if (result && messageMode === "normal")
             outboundDeliveredCount += 1;
         log?.info?.(`[${account.accountId}] clawchat-plugin-openclaw send complete to=${target.chatId}`);
         openclawLlmContextDebug.writeSnapshot({
@@ -558,7 +644,7 @@ export function createOpenclawClawlingReplyDispatcher(options) {
         });
         return result;
     };
-    const emitFullSegment = async (text, urls = []) => {
+    const emitFullSegment = async (text, urls = [], messageMode = "normal") => {
         if (outputVisibility !== "full" && !splitNormalBlockOutput) {
             appendBufferedText(text);
             appendBufferedUrls(urls);
@@ -572,24 +658,26 @@ export function createOpenclawClawlingReplyDispatcher(options) {
         const trimmed = text.trim();
         if (!trimmed && urls.length === 0)
             return;
-        const segmentKey = fullSegmentKey(trimmed, urls);
+        const segmentKey = fullSegmentKey(trimmed, urls, messageMode);
         if (emittedFullSegmentSet.has(segmentKey))
             return;
         emittedFullSegmentSet.add(segmentKey);
         const mediaFragments = await uploadMediaUrls(urls);
-        await sendStatic(trimmed, mediaFragments, [], { recordMessage: true });
+        await sendStatic(trimmed, mediaFragments, [], { recordMessage: true, messageMode });
     };
     const emitFullRuntimeText = async (label, text, urls = []) => {
         const summary = summarizeValue(text);
         if (!summary && urls.length === 0)
             return;
-        await emitFullSegment(summary ? `[${label}] ${summary}` : "", urls);
+        await emitFullSegment(summary ? `[${label}] ${summary}` : "", urls, "thinking");
     };
+    /** Process output (tool / command / patch / compaction / reasoning): `message_mode: "thinking"`. */
+    const emitProcessSegment = (text, urls = []) => emitFullSegment(text, urls, "thinking");
     // ----- Dispatcher -------------------------------------------------------
     const base = runtime.channel.reply.createReplyDispatcherWithTyping({
         humanDelay,
         onReplyStart: async () => {
-            emitTyping(true);
+            startTyping();
         },
         deliver: async (payload, info) => {
             if (consumeTerminalSend(info?.kind ?? "unknown"))
@@ -614,7 +702,7 @@ export function createOpenclawClawlingReplyDispatcher(options) {
             if (payload.isReasoning) {
                 if (outputVisibility !== "full")
                     return;
-                await emitFullSegment(text, urls);
+                await emitProcessSegment(text, urls);
                 const trimmed = text.trim();
                 if (trimmed)
                     reasoningText = reasoningText ? `${reasoningText}\n${trimmed}` : trimmed;
@@ -645,6 +733,7 @@ export function createOpenclawClawlingReplyDispatcher(options) {
                 finalDeliverySeen = true;
                 if (isClawChatNoopResponseText(text) && !richFragment && urls.length === 0) {
                     log?.info?.(`[${account.accountId}] clawchat-plugin-openclaw final suppressed: no-reply token`);
+                    failStream("no-reply");
                     openclawLlmContextDebug.writeSnapshot({
                         visibility: "host_event",
                         trace: {
@@ -670,6 +759,7 @@ export function createOpenclawClawlingReplyDispatcher(options) {
                     !richFragment &&
                     finalUrls.length === 0) {
                     log?.info?.(`[${account.accountId}] clawchat-plugin-openclaw final suppressed: no-reply token`);
+                    failStream("no-reply");
                     return;
                 }
                 const mediaFragments = await uploadMediaUrls(finalUrls);
@@ -687,23 +777,29 @@ export function createOpenclawClawlingReplyDispatcher(options) {
                 void emitFullRuntimeText("error", errorText);
         },
         onIdle: async () => {
-            emitTyping(false);
+            stopTyping();
             if (runDone)
                 return;
             runDone = true;
-            if (finalDeliverySeen)
-                return;
-            const fallbackText = bufferedOutputText.trim();
-            const fallbackUrls = bufferedOutputUrls.slice();
-            if (!fallbackText && fallbackUrls.length === 0)
-                return;
-            const mediaFragments = await uploadMediaUrls(fallbackUrls);
-            const result = await sendStatic(fallbackText, mediaFragments, [], { recordMessage: true });
-            if (result?.messageId)
-                recordThinkingIfLinked(result.messageId);
+            try {
+                if (finalDeliverySeen)
+                    return;
+                const fallbackText = bufferedOutputText.trim();
+                const fallbackUrls = bufferedOutputUrls.slice();
+                if (!fallbackText && fallbackUrls.length === 0)
+                    return;
+                const mediaFragments = await uploadMediaUrls(fallbackUrls);
+                const result = await sendStatic(fallbackText, mediaFragments, [], { recordMessage: true });
+                if (result?.messageId)
+                    recordThinkingIfLinked(result.messageId);
+            }
+            finally {
+                // A preview nothing materialized must not linger as an open stream.
+                failStream("undelivered");
+            }
         },
         onCleanup: () => {
-            emitTyping(false);
+            stopTyping();
         },
     });
     return {
@@ -712,7 +808,15 @@ export function createOpenclawClawlingReplyDispatcher(options) {
         replyOptions: {
             ...base.replyOptions,
             sourceReplyDeliveryMode: "automatic",
-            disableBlockStreaming: !splitNormalBlockOutput,
+            typingKeepalive: false,
+            // Streaming previews the assistant message and the final materializes it,
+            // so host block chunks (which split one message arbitrarily) stay off.
+            disableBlockStreaming: streamEnabled ? true : !splitNormalBlockOutput,
+            onPartialReply: streamEnabled
+                ? (payload) => {
+                    onStreamPartial(typeof payload?.text === "string" ? payload.text : "");
+                }
+                : undefined,
             suppressDefaultToolProgressMessages: true,
             allowProgressCallbacksWhenSourceDeliverySuppressed: splitFullOutput ? true : undefined,
             onReasoningStream: splitFullOutput
@@ -730,7 +834,7 @@ export function createOpenclawClawlingReplyDispatcher(options) {
                 ? async (payload) => {
                     if (consumeTerminalSend("tool-start"))
                         return;
-                    await emitFullSegment(formatToolStartSummary(payload));
+                    await emitProcessSegment(formatToolStartSummary(payload));
                 }
                 : undefined,
             onToolResult: splitFullOutput
@@ -763,28 +867,28 @@ export function createOpenclawClawlingReplyDispatcher(options) {
                 ? async (payload) => {
                     if (consumeTerminalSend("command-output"))
                         return;
-                    await emitFullSegment(formatCommandOutputSummary(payload));
+                    await emitProcessSegment(formatCommandOutputSummary(payload));
                 }
                 : undefined,
             onPatchSummary: splitFullOutput
                 ? async (payload) => {
                     if (consumeTerminalSend("patch-summary"))
                         return;
-                    await emitFullSegment(formatPatchSummary(payload));
+                    await emitProcessSegment(formatPatchSummary(payload));
                 }
                 : undefined,
             onCompactionStart: splitFullOutput
                 ? async () => {
                     if (consumeTerminalSend("compaction-start"))
                         return;
-                    await emitFullSegment("[compaction] started");
+                    await emitProcessSegment("[compaction] started");
                 }
                 : undefined,
             onCompactionEnd: splitFullOutput
                 ? async () => {
                     if (consumeTerminalSend("compaction-end"))
                         return;
-                    await emitFullSegment("[compaction] finished");
+                    await emitProcessSegment("[compaction] finished");
                 }
                 : undefined,
         },

package/dist/src/reply-stream.js

@@ -0,0 +1,208 @@
+/**
+ * Outbound reply streaming (protocol §8) for one assistant message.
+ *
+ * Lifecycle on the wire (§8.4 finalize-reply pattern):
+ *
+ *   message.created(M) → message.add(M, seq 0..n)* → message.done(M)
+ *   → message.reply (message_id = M, the polished final)
+ *
+ * `message.done` carries the FINAL text, not the last partial: adds are
+ * throttled, so the last one that went out can be well short of the answer,
+ * and the server materializes its merged reply from the stream. `finish`
+ * therefore takes the final text, sends whatever tail of it the throttle held
+ * back as one last add, and closes with the whole text. A final that does not
+ * extend what was shown cannot be appended (§8.2) — the stream is failed and
+ * the final goes out under its own id.
+ *
+ * or, when the reply turns out not to be sendable (no-reply token, run
+ * aborted, nothing delivered): message.created(M) → … → message.failed(M),
+ * which aborts the stream without materializing anything.
+ *
+ * Streaming frames get no ack (§8.5) and no server-side mention repair, so the
+ * stream only ever carries plain text; mentions, media and rich fragments ride
+ * on the final materialized message, which reuses M so the stored row collapses
+ * to the final reply.
+ *
+ * No-reply guard. A partial must never show something that later turns out to
+ * be a no-reply: nothing is opened until the text is at least
+ * STREAM_HOLD_CHARS long and is not a no-reply / silence marker; a trailing
+ * fragment that could be the start of a no-reply token is held back; and if a
+ * token shows up later the stream stops growing and is failed at finalize.
+ */
+import { EVENT } from "./protocol-types.js";
+import { isClawChatNoopResponseText } from "./profile-prompt.js";
+import { isNoReplyTokenPrefix } from "./no-reply.js";
+/** Minimum visible (trimmed) length before a stream is opened. */
+export const STREAM_HOLD_CHARS = 32;
+/** Minimum spacing between two `message.add` frames for one stream. */
+export const STREAM_MIN_ADD_INTERVAL_MS = 250;
+/** How far back from the end a partial no-reply token is looked for. */
+const TOKEN_TAIL_WINDOW = 40;
+/**
+ * Decide how much of a cumulative partial `text` may be shown.
+ *  - `poisoned`: the text is (or contains) a no-reply token; never show it.
+ *  - `hold`: too short to be sure yet.
+ *  - `ok`: `text` with any trailing possible-token prefix cut off.
+ */
+export function streamableText(text) {
+    if (isClawChatNoopResponseText(text))
+        return { kind: "poisoned" };
+    let safe = text;
+    for (let i = Math.max(0, text.length - TOKEN_TAIL_WINDOW); i < text.length; i += 1) {
+        const ch = text[i];
+        if (/\s/.test(ch))
+            continue;
+        if (isNoReplyTokenPrefix(text.slice(i))) {
+            safe = text.slice(0, i);
+            break;
+        }
+    }
+    if (safe.trim().length < STREAM_HOLD_CHARS)
+        return { kind: "hold" };
+    return { kind: "ok", text: safe };
+}
+export function createReplyStream(options) {
+    const now = options.now ?? Date.now;
+    const prefix = options.logPrefix ?? "clawchat-plugin-openclaw";
+    let messageId = null;
+    let closed = false;
+    let poisoned = false;
+    let diverged = false;
+    let sent = "";
+    let sequence = -1;
+    let lastAddAt = 0;
+    let startedAt = 0;
+    const canSend = () => {
+        const client = options.client;
+        if (client.transportState !== undefined && client.transportState !== "open")
+            return false;
+        if (client.state !== undefined && client.state !== "connected")
+            return false;
+        return true;
+    };
+    const emit = (event, payload) => {
+        try {
+            options.client.emitRaw(event, payload, { chat_id: options.chatId });
+            return true;
+        }
+        catch (error) {
+            options.log?.error?.(`${prefix} stream ${event} failed msg=${messageId}: ${String(error)}`);
+            return false;
+        }
+    };
+    const streamingState = (status, completedAt) => ({
+        status,
+        sequence: Math.max(sequence, 0),
+        mutation_policy: "append_text_only",
+        started_at: startedAt,
+        completed_at: completedAt,
+    });
+    const sendAdd = (next, at) => {
+        sequence += 1;
+        const ok = emit(EVENT.MESSAGE_ADD, {
+            message_id: messageId,
+            sequence,
+            mutation: { type: "append", target_fragment_index: 0 },
+            fragments: [{ kind: "text", text: next, delta: next.slice(sent.length) }],
+            streaming: streamingState("streaming", null),
+            added_at: at,
+        });
+        if (!ok) {
+            sequence -= 1;
+            return false;
+        }
+        sent = next;
+        lastAddAt = at;
+        return true;
+    };
+    const fail = (reason) => {
+        if (!messageId || closed)
+            return;
+        closed = true;
+        const at = now();
+        emit(EVENT.MESSAGE_FAILED, {
+            message_id: messageId,
+            fragments: [{ kind: "text", text: sent }],
+            streaming: streamingState("failed", at),
+            completed_at: at,
+        });
+        options.log?.info?.(`${prefix} stream failed msg=${messageId} reason=${reason}`);
+    };
+    return {
+        update(text) {
+            if (closed || poisoned || diverged)
+                return;
+            const decision = streamableText(text);
+            if (decision.kind === "poisoned") {
+                poisoned = true;
+                options.log?.info?.(`${prefix} stream halted: no-reply token in partial msg=${messageId ?? "-"}`);
+                return;
+            }
+            if (decision.kind === "hold")
+                return;
+            const next = decision.text;
+            if (messageId && !next.startsWith(sent)) {
+                // §8.2 delta invariant cannot hold for a rewrite; stop growing the
+                // stream and let the final message (same id) carry the real text.
+                diverged = true;
+                return;
+            }
+            if (next === sent)
+                return;
+            if (!canSend())
+                return;
+            if (!messageId) {
+                const id = options.mintMessageId();
+                startedAt = now();
+                if (!emit(EVENT.MESSAGE_CREATED, { message_id: id, message_mode: "normal" }))
+                    return;
+                messageId = id;
+                options.log?.info?.(`${prefix} stream opened msg=${id} to=${options.chatId}`);
+            }
+            else if (now() - lastAddAt < STREAM_MIN_ADD_INTERVAL_MS) {
+                return;
+            }
+            sendAdd(next, now());
+        },
+        diverges(text) {
+            if (!messageId || closed)
+                return false;
+            const decision = streamableText(text);
+            return decision.kind === "ok" && !decision.text.startsWith(sent);
+        },
+        isOpen() {
+            return messageId !== null && !closed;
+        },
+        shownText() {
+            return sent;
+        },
+        finish(finalText) {
+            if (!messageId || closed)
+                return null;
+            if (streamableText(finalText).kind === "poisoned") {
+                fail("no-reply");
+                return null;
+            }
+            // Trailing whitespace a partial carried may be trimmed off the final.
+            if (!finalText.startsWith(sent.trimEnd())) {
+                fail("superseded");
+                return null;
+            }
+            if (finalText.length > sent.length && finalText.startsWith(sent)) {
+                // Past the throttle: this is the last frame before done.
+                sendAdd(finalText, now());
+            }
+            closed = true;
+            const at = now();
+            emit(EVENT.MESSAGE_DONE, {
+                message_id: messageId,
+                fragments: [{ kind: "text", text: finalText }],
+                streaming: streamingState("done", at),
+                completed_at: at,
+            });
+            options.log?.info?.(`${prefix} stream done msg=${messageId} text_len=${finalText.length}`);
+            return messageId;
+        },
+        fail,
+    };
+}

package/dist/src/runtime.js

@@ -33,6 +33,7 @@ import { loadClawChatPromptMetadata, renderClawChatProfilePrompt, resolveSenderR
 import { refreshGroupProfile, syncFirstSeenClawChatProfiles } from "./profile-sync.js";
 import { pullGroupMetadata, pullOwnerMetadata } from "./clawchat-metadata.js";
 import { deleteClawChatMemoryFile, readClawChatMemoryFile } from "./clawchat-memory.js";
+import { registerMentionRosterResolver } from "./mention-autolink.js";
 import { clearClawChatPromptInjectionForSession, stageClawChatPromptInjection, } from "./prompt-injection.js";
 import { createGroupMessageCoalescer } from "./group-message-coalescer.js";
 import { openclawLlmContextDebug } from "./llm-context-debug.js";
@@ -3229,6 +3230,23 @@ export async function startOpenclawClawlingGateway(params) {
         return;
     }
     activeClients.set(accountId, client);
+    // Text "@name" autolinking on outbound group sends reads the same cached
+    // roster (participant ids + nicknames) the group prompt shows the model.
+    const unregisterMentionRoster = registerMentionRosterResolver(accountId, async (groupId) => {
+        const memoryRoot = resolveMemoryRootForPeer({ kind: "group", id: groupId });
+        if (!memoryRoot)
+            return [];
+        let ownerMetadata = null;
+        try {
+            const ownerFile = await readClawChatMemoryFile(memoryRoot, { targetType: "owner", targetId: "owner" });
+            ownerMetadata = ownerFile.exists ? ownerFile.metadata : null;
+        }
+        catch {
+            ownerMetadata = null;
+        }
+        const participants = await loadGroupParticipantsForPrompt({ memoryRoot, groupId, ownerMetadata });
+        return participants.map((participant) => ({ userId: participant.id, name: participant.name }));
+    });
     log?.info?.(`[${accountId}] clawchat-plugin-openclaw runtime active client registered`);
     setStatus({
         ...getStatus(),
@@ -3240,6 +3258,7 @@ export async function startOpenclawClawlingGateway(params) {
     await waitUntilAbort(abortSignal, async () => {
         log?.info?.(`[${accountId}] clawchat-plugin-openclaw runtime abort received; closing client`);
         activeClients.delete(accountId);
+        unregisterMentionRoster();
         closingForAbort = true;
         clearBootstrapRetry();
         // §A.1 — stop the proactive refresh timer on shutdown.

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.15.2";
+export const DEFAULT_SKILLS_REF = "skills-v1.16.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.js

@@ -1449,11 +1449,18 @@ export function registerOpenclawClawlingTools(api, options = {}) {
         return {
             name: "clawchat_orchestrate_set_agent_behavior",
             label: "Rewrite A Sibling's System Prompt",
-            description: toolDescription("Replace the WHOLE system prompt (behavior) of one of the owner's other agents. " +
+            description: toolDescription("Stage/room speaking rules go in the group description, not here; for a stage, append the stage sentence below to off-desktop members (clawchat-orchestration skill). " +
+                "Replace the WHOLE system prompt (behavior) of one of the owner's other agents. " +
                 "TRIGGER — invoke when the owner asks to change how another agent behaves, talks, or what it is for. " +
                 "This REPLACES the entire field — call clawchat_orchestrate_get_agent first, edit the text you got back, and send the full new value. " +
                 "Sending a fragment deletes everything else and the owner cannot recover it. Max 3000 runes. " +
-                "Nickname and bio cannot be changed here."),
+                "Nickname and bio cannot be changed here. " +
+                "Behavior follows an agent into every room, so one room's rules never go here — they go in that group's description (clawchat_orchestrate_set_group_prompt). " +
+                "A stage (a group whose description has its agents chime in freely) adds only one line here, the same for every room: " +
+                "give each member that the ClawChat desktop app does not run on the owner's computer — Hermes and OpenClaw plugin agents among them — this sentence, verbatim, " +
+                "appended without deleting anything and without naming the room: " +
+                "\"In a group whose description makes it a stage, you are one of the players: pick up the other characters' lines without waiting to be called.\" " +
+                "Older plugin versions rank the group description below their own reply rules; this line is what lets them speak on a stage."),
             parameters: ClawchatOrchSetAgentBehaviorSchema,
             async execute(_callId, params) {
                 return await recordClawchatToolCall(accountId, "clawchat_orchestrate_set_agent_behavior", params, async () => {
@@ -1497,11 +1504,15 @@ export function registerOpenclawClawlingTools(api, options = {}) {
         return {
             name: "clawchat_orchestrate_set_group_prompt",
             label: "Rewrite A Group's System Prompt",
-            description: toolDescription("Replace the WHOLE system prompt (description) of a group the owner administers. " +
+            description: toolDescription("Stage/room speaking rules go here, in the group description; for a stage, also append the stage sentence to off-desktop members' behavior (clawchat-orchestration skill). " +
+                "Replace the WHOLE system prompt (description) of a group the owner administers. " +
                 "TRIGGER — invoke when the owner asks to change how a group behaves as a whole. " +
                 "This REPLACES the entire field — call clawchat_orchestrate_get_group first and send the full new value. " +
                 "Sending a fragment deletes everything else and the owner cannot recover it. Max 3000 runes. " +
-                "The group title cannot be changed here."),
+                "The group title cannot be changed here. " +
+                "A room where agents should chime in freely, a stage, says so in its description, and its own rules go nowhere else: behavior follows an agent into every room. " +
+                "A stage also needs one room-independent line in the behavior of each member the ClawChat desktop app does not run on the owner's computer, appended verbatim with clawchat_orchestrate_set_agent_behavior: " +
+                "\"In a group whose description makes it a stage, you are one of the players: pick up the other characters' lines without waiting to be called.\""),
             parameters: ClawchatOrchSetGroupPromptSchema,
             async execute(_callId, params) {
                 return await recordClawchatToolCall(accountId, "clawchat_orchestrate_set_group_prompt", params, async () => {

package/openclaw.plugin.json

@@ -124,6 +124,7 @@
       "forwardThinking": { "type": "boolean" },
       "forwardToolCalls": { "type": "boolean" },
       "richInteractions": { "type": "boolean" },
+      "streamReplies": { "type": "boolean" },
       "awarenessNote": { "type": "boolean" },
       "friendGreeting": { "type": "boolean" },
       "livewareSample": { "type": "boolean" },
@@ -197,6 +198,7 @@
             "forwardThinking": { "type": "boolean" },
             "forwardToolCalls": { "type": "boolean" },
             "richInteractions": { "type": "boolean" },
+            "streamReplies": { "type": "boolean" },
             "awarenessNote": { "type": "boolean" },
             "friendGreeting": { "type": "boolean" },
             "livewareSample": { "type": "boolean" },
@@ -276,6 +278,7 @@
           "forwardThinking": { "type": "boolean" },
           "forwardToolCalls": { "type": "boolean" },
           "richInteractions": { "type": "boolean" },
+          "streamReplies": { "type": "boolean" },
           "awarenessNote": { "type": "boolean" },
           "friendGreeting": { "type": "boolean" },
           "livewareSample": { "type": "boolean" },
@@ -349,6 +352,7 @@
                 "forwardThinking": { "type": "boolean" },
                 "forwardToolCalls": { "type": "boolean" },
                 "richInteractions": { "type": "boolean" },
+                "streamReplies": { "type": "boolean" },
                 "awarenessNote": { "type": "boolean" },
                 "friendGreeting": { "type": "boolean" },
                 "livewareSample": { "type": "boolean" },

package/package.json

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