openclaw-lark-multi-agent 1.8.20 → 1.8.21

package/dist/config.d.ts

@@ -1,12 +1,26 @@
 import { type Locale } from "./i18n.js";
+/** Profile used by a bot that does not name one.
+ *
+ * Keeps every pre-profile configuration on the historical default. */
+export declare const DEFAULT_BOT_PROFILE = "main";
 export interface BotConfig {
     name: string;
     appId: string;
     appSecret: string;
-    model: string;
+    /** Model routed for this bot. Optional: when absent or blank the bot
+     * follows the model of its OpenClaw profile instead of overriding it. */
+    model?: string;
     locale?: Locale;
     /** Optional per-bot thinking level (informational fallback for footers). */
     thinking?: string;
+    /** OpenClaw agent/profile that owns this bot's sessions.
+     *
+     * Optional for backward compatibility: a bot that does not name a profile
+     * keeps the historical `main` profile, so existing configs behave exactly
+     * as before. When set, the bot's sessions are addressed under that
+     * profile, giving it that profile's own workspace, memory and identity.
+     * Defaults to "main" when absent or blank. */
+    profile?: string;
 }
 export interface OpenClawConfig {
     baseUrl: string;

package/dist/config.js

@@ -1,6 +1,10 @@
 import { readFileSync, writeFileSync } from "fs";
 import { resolve } from "path";
 import { normalizeLocale } from "./i18n.js";
+/** Profile used by a bot that does not name one.
+ *
+ * Keeps every pre-profile configuration on the historical default. */
+export const DEFAULT_BOT_PROFILE = "main";
 export function loadConfig(path) {
     const configPath = path || resolve(process.cwd(), "config.json");
     const raw = readFileSync(configPath, "utf-8");
@@ -12,13 +16,21 @@ export function loadConfig(path) {
         throw new Error("No bots configured");
     }
     for (const bot of config.bots) {
-        if (!bot.appId || !bot.appSecret || !bot.model) {
-            throw new Error(`Bot "${bot.name}" missing appId, appSecret, or model`);
+        if (!bot.appId || !bot.appSecret) {
+            throw new Error(`Bot "${bot.name}" missing appId or appSecret`);
         }
     }
     config.locale = normalizeLocale(config.locale);
     for (const bot of config.bots) {
         bot.locale = normalizeLocale(bot.locale || config.locale);
+        // A bot without a profile keeps the historical `main` profile. Older
+        // configs stay byte-identical in behaviour; a profile is only a routing
+        // choice, never a required field.
+        const profile = String(bot.profile == null ? "" : bot.profile).trim();
+        bot.profile = profile || DEFAULT_BOT_PROFILE;
+        // An empty model means "follow the profile's own model".
+        const model = String(bot.model == null ? "" : bot.model).trim();
+        bot.model = model || undefined;
     }
     // Validate uniqueness
     const names = config.bots.map((b) => b.name);

package/dist/feishu-bot.d.ts

@@ -93,8 +93,6 @@ export declare class FeishuBot {
     private deliveryRetryTimers;
     /** Last time a real assistant-visible reply was successfully handed to the delivery pipeline. */
     private lastRealDeliveryAt;
-    /** Per-chat: whether we've already sent the high-context alert this cycle. */
-    private contextAlerted;
     /** Active pre-admission target for the current chat operation. */
     private activeDeliveryTargets;
     /** Stable targets for concurrent runs in one chat. A steer admission can
@@ -120,7 +118,21 @@ export declare class FeishuBot {
      * Get the session key for a specific chat.
      * Format: lma-<botname>-<chatId>
      */
+    /** OpenClaw profile that owns this bot's sessions.
+     *
+     * Defaults to "main" so a configuration written before profiles existed
+     * keeps its historical behaviour exactly. */
+    private get profile();
     getSessionKey(chatId: string): string;
+    /** Physical session key for this bot: the logical key addressed under the
+     * bot's OpenClaw profile.
+     *
+     * The LOGICAL key (getSessionKey) stays profile-free so durable records keep
+     * their historical shape and never need a migration. Every key that is
+     * actually handed to the Gateway goes through this method, so a bot bound to
+     * a non-default profile owns its sessions under that profile (its own
+     * workspace, memory and identity) while the stored records stay compatible. */
+    physicalSessionKey(chatId: string): string;
     private chatLocale;
     private isEn;
     private lmaBridgePolicy;
@@ -164,6 +176,14 @@ export declare class FeishuBot {
     private handleResolvedMessage;
     /** Separate guarded-admission proof. Aggregate busy never becomes idle. */
     private observedFollowupGuard;
+    /** How long an unconfirmed input may stay silent before the user is told.
+     *
+     * A fixed 60s window misfired on every slow session: measured reply latency
+     * in a busy group was p50 3.8min / p90 20.2min / max 135min, so 85% of real
+     * replies exceeded the old threshold and every one of them produced a false
+     * "not confirmed" notice. Scale the window with the session's own observed
+     * latency so a healthy slow run is never reported as stuck. */
+    private unconfirmedGraceMs;
     /** A positive refusal must be durable AND explained to the sender. */
     private retainChangedFollowup;
     private explainUnconfirmedFollowup;
@@ -266,11 +286,15 @@ export declare class FeishuBot {
      *  or 0 if it cannot be determined. Same basis as /status. */
     private getContextUsagePercent;
     /**
-     * After a reply is delivered, alert the user once if context usage crossed the
-     * threshold (default 80%), so they can compact before a session bloats into the
-     * timeout/lock/overflow failure modes. We only alert on a fresh crossing: once
-     * alerted we stay quiet until usage drops back below the threshold (e.g. after
-     * a compact), then re-arm.
+     * After a message completes, alert the user when context usage is at or above
+     * the threshold (default 80%), so they can compact before the session bloats
+     * into the timeout/lock/overflow failure modes.
+     *
+     * The check runs after EVERY completed message and re-notifies on every message
+     * while usage stays above the threshold. There is deliberately no per-chat
+     * "already warned" latch: with one, a single failed send (or a stale latch) would
+     * silently suppress every later warning, and the user would stop being told to
+     * compact while their context keeps growing.
      */
     private maybeAlertHighContext;
     /** True when the agent's reply is exactly a completion phrase (zh or en,
@@ -486,6 +510,12 @@ export declare class FeishuBot {
      * runs for the session, clears the busy lock and every pending trigger, and
      * resets stuck reactions so new messages are processed normally again.
      */
+    /** Release every peer bot's in-memory scheduling state for one chat.
+     * Each bot instance keeps its own queueRuns / queueOwners / busyChats /
+     * pendingAckMessages maps; a durable row cleanup cannot reach those. A
+     * group-scoped /stop must retire them too, otherwise the peer's queue owner
+     * survives and its next message is treated as "busy" forever. */
+    private releasePeerBotsForChat;
     private handleStopCommand;
     /**
      * Fetch chat info (name, type, members) via Feishu API and cache in SQLite.

package/dist/feishu-bot.js

@@ -32,7 +32,21 @@ export class SendDeadlineError extends Error {
     }
 }
 const nonemptyReceipt = (value) => typeof value === 'string' && !!value.trim();
-const canonicalPhysicalSessionKey = (key) => /^agent:[^:]+:/.test(key) ? key : `agent:main:${key}`;
+/** Resolve the PHYSICAL session key for a logical LMA key.
+ *
+ * A bot may be bound to a specific OpenClaw profile. The profile selects the
+ * agent that owns the session, so the physical key carries it as an
+ * `agent:<profile>:` prefix. A key that already carries an explicit
+ * `agent:<id>:` prefix is left untouched.
+ *
+ * With the default profile this is byte-identical to the historical
+ * `agent:main:<key>`, so existing durable records keep matching. */
+const canonicalPhysicalSessionKey = (key, profile) => {
+    if (/^agent:[^:]+:/.test(key))
+        return key;
+    const agent = String(profile || "main").trim() || "main";
+    return `agent:${agent}:${key}`;
+};
 const require = createRequire(import.meta.url);
 const LMA_VERSION = require("../package.json").version;
 const MAX_BOT_STREAK = 10;
@@ -329,8 +343,6 @@ export class FeishuBot {
     deliveryRetryTimers = new Map();
     /** Last time a real assistant-visible reply was successfully handed to the delivery pipeline. */
     lastRealDeliveryAt = new Map();
-    /** Per-chat: whether we've already sent the high-context alert this cycle. */
-    contextAlerted = new Map();
     /** Active pre-admission target for the current chat operation. */
     activeDeliveryTargets = new Map();
     /** Stable targets for concurrent runs in one chat. A steer admission can
@@ -387,10 +399,11 @@ export class FeishuBot {
         // Go / Go-Checker supervision (design: lma-go-checker-design-20260917).
         this.goController = new GoController({
             botName: config.name,
-            fallbackModel: config.model,
+            fallbackModel: config.model || "",
+            profile: this.profile,
             store,
             client: openclawClient,
-            executorSessionKeyFor: (chatId) => this.getSessionKey(chatId),
+            executorSessionKeyFor: (chatId) => this.physicalSessionKey(chatId),
             notify: (chatId, text) => this.sendOrdered(chatId, () => this.sendMessage(chatId, text)),
             reply: (messageId, text) => this.replyMessage(messageId, text),
             deliverExecutorResult: (chatId, result, goId) => this.deliverGoExecutorResult(chatId, result, goId),
@@ -405,7 +418,7 @@ export class FeishuBot {
             if (typeof exactKey !== "string" || typeof sessionId !== "string" || typeof runId !== "string")
                 return;
             for (const job of this.store.listActiveGoJobs(this.config.name)) {
-                if (exactKey !== job.executorSessionKey && exactKey !== `agent:main:${job.executorSessionKey}`)
+                if (exactKey !== job.executorSessionKey && exactKey !== canonicalPhysicalSessionKey(job.executorSessionKey, this.profile))
                     continue;
                 if (sessionId !== job.executorSessionId)
                     continue;
@@ -469,9 +482,27 @@ export class FeishuBot {
      * Get the session key for a specific chat.
      * Format: lma-<botname>-<chatId>
      */
+    /** OpenClaw profile that owns this bot's sessions.
+     *
+     * Defaults to "main" so a configuration written before profiles existed
+     * keeps its historical behaviour exactly. */
+    get profile() {
+        return String(this.config.profile || "main").trim() || "main";
+    }
     getSessionKey(chatId) {
         return `lma-${this.config.name.toLowerCase()}-${chatId}`;
     }
+    /** Physical session key for this bot: the logical key addressed under the
+     * bot's OpenClaw profile.
+     *
+     * The LOGICAL key (getSessionKey) stays profile-free so durable records keep
+     * their historical shape and never need a migration. Every key that is
+     * actually handed to the Gateway goes through this method, so a bot bound to
+     * a non-default profile owns its sessions under that profile (its own
+     * workspace, memory and identity) while the stored records stay compatible. */
+    physicalSessionKey(chatId) {
+        return canonicalPhysicalSessionKey(this.getSessionKey(chatId), this.profile);
+    }
     chatLocale(chatId) {
         return normalizeLocale(chatId ? this.store.getChatLocale(chatId) || this.locale : this.locale);
     }
@@ -495,7 +526,11 @@ export class FeishuBot {
      * Lazy: only creates on first message in that chat.
      */
     async ensureSession(chatId, setupFence) {
-        const sessionKey = this.getSessionKey(chatId);
+        // The cache is keyed by the LOGICAL key so it stays profile-free and
+        // consistent with the rest of the durable bookkeeping; the Gateway is
+        // always addressed with the PHYSICAL key (profile included).
+        const logicalKey = this.getSessionKey(chatId);
+        const sessionKey = this.physicalSessionKey(chatId);
         await this.assertIdentityEffect();
         const held = this.identityEffects?.getStore();
         const expectedSessionId = held?.item.target.sessionId || setupFence?.sessionId;
@@ -506,9 +541,12 @@ export class FeishuBot {
             if (info?.session?.sessionId !== setupFence.sessionId || info.session.archived)
                 throw new SupersededObservation('retained setup physical target changed');
         }
-        if (this.initializedSessions.has(sessionKey)) {
+        if (this.initializedSessions.has(logicalKey)) {
             // Already initialized this process lifetime, just ensure model
-            const corrected = (expectedSessionId ? await this.openclawClient.ensureModel(sessionKey, this.config.model, { sessionId: expectedSessionId, guard: setupGuard }) : await this.openclawClient.ensureModel(sessionKey, this.config.model));
+            // No configured model means the bot follows its profile's own model.
+            const corrected = this.config.model
+                ? (expectedSessionId ? await this.openclawClient.ensureModel(sessionKey, this.config.model, { sessionId: expectedSessionId, guard: setupGuard }) : await this.openclawClient.ensureModel(sessionKey, this.config.model))
+                : false;
             setupGuard();
             if (corrected) {
                 console.log(`[${this.config.name}] Model auto-corrected to ${this.config.model}`);
@@ -524,7 +562,9 @@ export class FeishuBot {
             if (existing?.session) {
                 // Session exists — preserve it, only ensure model is correct
                 console.log(`[${this.config.name}] Session exists: ${sessionKey} (tokens: ${existing.session.totalTokens || 0})`);
-                const corrected = (expectedSessionId ? await this.openclawClient.ensureModel(sessionKey, this.config.model, { sessionId: expectedSessionId, guard: setupGuard }) : await this.openclawClient.ensureModel(sessionKey, this.config.model));
+                const corrected = this.config.model
+                    ? (expectedSessionId ? await this.openclawClient.ensureModel(sessionKey, this.config.model, { sessionId: expectedSessionId, guard: setupGuard }) : await this.openclawClient.ensureModel(sessionKey, this.config.model))
+                    : false;
                 setupGuard();
                 if (corrected) {
                     console.log(`[${this.config.name}] Model auto-corrected to ${this.config.model}`);
@@ -534,11 +574,13 @@ export class FeishuBot {
                 // Session doesn't exist — create new
                 await this.openclawClient.createSession({
                     key: sessionKey,
-                    model: this.config.model,
+                    model: this.config.model || "",
                     label: `LMA: ${this.config.name} [${chatId.slice(-8)}]`,
                 });
-                // Always patch model after create to ensure it takes effect
-                await this.openclawClient.patchSession({ key: sessionKey, model: this.config.model });
+                // Only patch when a model is configured; otherwise the profile's own
+                // model must be left untouched.
+                if (this.config.model)
+                    await this.openclawClient.patchSession({ key: sessionKey, model: this.config.model });
                 await this.injectBridgePolicy(sessionKey);
                 console.log(`[${this.config.name}] Session created: ${sessionKey} (model: ${this.config.model})`);
             }
@@ -550,7 +592,7 @@ export class FeishuBot {
             throw err;
         }
         setupGuard();
-        this.initializedSessions.add(sessionKey);
+        this.initializedSessions.add(logicalKey);
         // Subscribe to session events (proactive messages + tool calls)
         this.openclawClient.setVerboseTranscriptDelivery(sessionKey, this.store.getBotVerbose(this.config.name, chatId));
         await this.openclawClient.subscribeSession(sessionKey, async (text, meta) => {
@@ -604,7 +646,7 @@ export class FeishuBot {
                 console.error(`[${this.config.name}] Failed to deliver proactive msg:`, err.message);
             }
         }, async (meta) => {
-            if (!meta.runId || this.store.isStoppedObservation(`agent:main:${sessionKey.replace(/^agent:[^:]+:/, '')}`, meta.runId))
+            if (!meta.runId || this.store.isStoppedObservation(canonicalPhysicalSessionKey(sessionKey.replace(/^agent:[^:]+:/, ''), this.profile), meta.runId))
                 return;
             if (this.store.hasUnconfirmedRunDelivery(this.config.name, chatId, meta.runId))
                 return;
@@ -660,7 +702,7 @@ export class FeishuBot {
         await this.wsClient.start({ eventDispatcher: this.eventDispatcher });
         if (this.identityClosed)
             return;
-        console.log(`[${this.config.name}] Bot started (model: ${this.config.model}, open_id: ${this.botOpenId || "unknown"})`);
+        console.log(`[${this.config.name}] Bot started (model: ${this.config.model || `profile ${this.profile}`}, open_id: ${this.botOpenId || "unknown"})`);
         // Drain any unsynced messages left from previous run
         this.drainOnStartup();
         void this.drainIdentityIngress().catch(err => console.warn(`[${this.config.name}] Identity ingress recovery failed:`, err.message));
@@ -693,14 +735,14 @@ export class FeishuBot {
         });
     }
     captureIdentityTarget(messageId, chatId) {
-        const key = this.getSessionKey(chatId);
+        const key = this.physicalSessionKey(chatId);
         const work = (async () => {
             const info = await this.identitySessionInfo(key);
             if (this.identityClosed)
                 return;
             const session = info?.session;
             const target = typeof session?.sessionId === 'string' && session.sessionId.trim() && session.sessionId.length <= 256 && session.archived !== true
-                && (!session.key || typeof session.key === 'string' && canonicalPhysicalSessionKey(session.key) === canonicalPhysicalSessionKey(key))
+                && (!session.key || typeof session.key === 'string' && canonicalPhysicalSessionKey(session.key, this.profile) === canonicalPhysicalSessionKey(key, this.profile))
                 ? { state: 'bound', sessionKey: key, sessionId: session.sessionId } : { state: 'unbound', sessionKey: key };
             if (target.state === 'unbound')
                 console.warn(`[${this.config.name}] Identity input ${messageId} has no proven original physical session; retained without retargeting`);
@@ -880,7 +922,12 @@ export class FeishuBot {
                 if (this.identityTargetRepairs.has(item.messageId))
                     return;
                 item.target = this.store.getIdentityTarget(this.config.name, this.config.appId, item.messageId);
-                if (item.target.state !== 'bound' || !item.target.sessionId || item.target.sessionKey !== this.getSessionKey(item.chatId))
+                // An identity target may hold the physical key (current records) or the
+                // logical key (records written before profiles existed). Both denote the
+                // SAME session, so both are accepted here; comparing against only one
+                // form silently skips identity recovery and the message is never sent.
+                if (item.target.state !== 'bound' || !item.target.sessionId ||
+                    (item.target.sessionKey !== this.physicalSessionKey(item.chatId) && item.target.sessionKey !== this.getSessionKey(item.chatId)))
                     continue;
                 const info = await this.identitySessionInfo(item.target.sessionKey);
                 if (this.identityClosed)
@@ -1462,7 +1509,7 @@ export class FeishuBot {
                     const isOn = this.store.getBotVerbose(this.config.name, chatId);
                     const nextVerbose = !isOn;
                     this.store.setBotVerbose(this.config.name, chatId, nextVerbose);
-                    this.openclawClient.setVerboseTranscriptDelivery(this.getSessionKey(chatId), nextVerbose);
+                    this.openclawClient.setVerboseTranscriptDelivery(this.physicalSessionKey(chatId), nextVerbose);
                     if (isOn) {
                         await this.replyMessage(messageId, `🔇 ${this.config.name} Verbose 已关闭\n只影响当前 Bot 在当前会话的 Tool call 和中间文本显示`);
                     }
@@ -1730,9 +1777,23 @@ export class FeishuBot {
         if (!activity.followupAdmissionEligible || activity.identityConflict || activity.activeRunId && !noEffectRunId || activity.archived || status.archived ||
             !status.sessionId || status.sessionId !== activity.sessionId || !activity.expectedLeafEntryId)
             return;
-        return { sessionKey: canonicalPhysicalSessionKey(this.getSessionKey(chatId)), sessionId: status.sessionId, expectedLeafEntryId: activity.expectedLeafEntryId,
+        return { sessionKey: canonicalPhysicalSessionKey(this.getSessionKey(chatId), this.profile), sessionId: status.sessionId, expectedLeafEntryId: activity.expectedLeafEntryId,
             ...(noEffectRunId ? { nonInjectableRunId: noEffectRunId } : {}) };
     }
+    /** How long an unconfirmed input may stay silent before the user is told.
+     *
+     * A fixed 60s window misfired on every slow session: measured reply latency
+     * in a busy group was p50 3.8min / p90 20.2min / max 135min, so 85% of real
+     * replies exceeded the old threshold and every one of them produced a false
+     * "not confirmed" notice. Scale the window with the session's own observed
+     * latency so a healthy slow run is never reported as stuck. */
+    unconfirmedGraceMs(chatId) {
+        const observed = this.store.observedReplyLatencyMs(this.config.name, chatId);
+        const floor = 60_000;
+        if (!observed || !Number.isFinite(observed) || observed <= 0)
+            return floor;
+        return Math.min(Math.max(floor, Math.ceil(observed * 1.5)), 30 * 60_000);
+    }
     /** A positive refusal must be durable AND explained to the sender. */
     retainChangedFollowup(chatId, item, reason) {
         this.store.saveInsertion(this.config.name, chatId, item.rowId, item.insertionId, 'target_changed', { ...item, reason });
@@ -1749,7 +1810,7 @@ export class FeishuBot {
         for (const item of this.store.listInsertions(this.config.name, chatId)) {
             if (item.state !== 'pending' || item.attempted || item.followupAdmissionGuard || item.ordinaryEligible === false ||
                 item.ownerId !== saved.id || item.batchId !== saved.batchId || item.stopEpoch !== saved.stopEpoch || item.sessionId !== proof.sessionId ||
-                !item.sessionKey || canonicalPhysicalSessionKey(item.sessionKey) !== proof.sessionKey)
+                !item.sessionKey || canonicalPhysicalSessionKey(item.sessionKey, this.profile) !== proof.sessionKey)
                 continue;
             const source = this.store.getMessageByMessageId(item.messageId);
             if (source?.senderType !== 'human' || source.triggerKind !== 'normal')
@@ -1773,7 +1834,7 @@ export class FeishuBot {
             !this.queueOwners.get(chatId)?.triggerIds?.has(rowId);
         if (!unsubmitted())
             return;
-        await this.openclawClient.waitForSessionStop?.(this.getSessionKey(chatId));
+        await this.openclawClient.waitForSessionStop?.(this.physicalSessionKey(chatId));
         if (!unsubmitted())
             return;
         // Session creation/model setup is not agent admission. Initialize a truly
@@ -1799,15 +1860,15 @@ export class FeishuBot {
         }
         if (!unsubmitted() || this.queueRuns.has(chatId) || this.store.getDispatchCustody(this.config.name, chatId))
             return;
-        const status = await this.openclawClient.getSessionRuntimeStatus(this.getSessionKey(chatId));
+        const status = await this.openclawClient.getSessionRuntimeStatus(this.physicalSessionKey(chatId));
         if (!unsubmitted() || this.queueRuns.has(chatId) || this.store.getDispatchCustody(this.config.name, chatId))
             return;
         const current = this.store.getInsertion(this.config.name, chatId, rowId);
         if (current && (!current.activityUnbound || current.attempted))
             return;
-        if (current && (current.stopEpoch !== epoch || !current.sessionKey || canonicalPhysicalSessionKey(current.sessionKey) !== canonicalPhysicalSessionKey(this.getSessionKey(chatId))))
+        if (current && (current.stopEpoch !== epoch || !current.sessionKey || canonicalPhysicalSessionKey(current.sessionKey, this.profile) !== canonicalPhysicalSessionKey(this.getSessionKey(chatId), this.profile)))
             return;
-        const activity = await this.openclawClient.getSessionDispatchStatus(this.getSessionKey(chatId));
+        const activity = await this.openclawClient.getSessionDispatchStatus(this.physicalSessionKey(chatId));
         if (!unsubmitted() || this.queueRuns.has(chatId) || this.store.getDispatchCustody(this.config.name, chatId))
             return;
         // Another recovery/ingress lookup may have identified the root and begun
@@ -1823,6 +1884,13 @@ export class FeishuBot {
             !!current?.sessionId && !!status.sessionId && current.sessionId !== status.sessionId;
         const source = this.store.getMessageByMessageId(messageId);
         const ordinaryHuman = source?.id === rowId && source.chatId === chatId && source.senderType === 'human' && source.triggerKind === 'normal';
+        if (current?.followupBlocked && !archived && !generationConflict) {
+            this.store.saveInsertion(this.config.name, chatId, rowId, current.insertionId || JSON.stringify([this.config.appId, chatId, messageId]), 'pending', {
+                ...current, followupBlocked: false, followupAdmissionGuard: undefined, followupObservedAt: undefined,
+                reason: 'followup block cleared; awaiting admission re-observation',
+            }, Date.now() + 5000);
+            return;
+        }
         const proof = ordinaryHuman && compatible && !current?.followupBlocked && !archived ? this.observedFollowupGuard(chatId, status, activity) : undefined;
         const previous = current?.followupAdmissionGuard;
         if (previous && (archived || generationConflict)) {
@@ -1871,7 +1939,7 @@ export class FeishuBot {
             ...((archived || generationConflict) ? { followupBlocked: true } : {}),
             reason: identified ? 'current Gateway run observed; insertion custody only' : blockerReason,
         }, Date.now() + (identified ? 0 : 5000));
-        if (!identified && !proof && current?.unboundSince && Date.now() - current.unboundSince >= 60_000 &&
+        if (!identified && !proof && current?.unboundSince && Date.now() - current.unboundSince >= this.unconfirmedGraceMs(chatId) &&
             (archived || generationConflict || activity.busyConfirmed || current.restrictedObservation))
             this.explainUnconfirmedFollowup(chatId, { ...current, rowId, messageId });
     }
@@ -1886,7 +1954,7 @@ export class FeishuBot {
         const source = this.store.getMessageByMessageId(item.messageId);
         if (item.state !== 'pending' || item.attempted || item.ordinaryEligible === false || !item.sessionId ||
             !source || source.id !== item.rowId || source.chatId !== chatId || source.senderType !== 'human' || source.triggerKind !== 'normal' ||
-            !item.sessionKey || canonicalPhysicalSessionKey(item.sessionKey) !== canonicalPhysicalSessionKey(this.getSessionKey(chatId)))
+            !item.sessionKey || canonicalPhysicalSessionKey(item.sessionKey, this.profile) !== canonicalPhysicalSessionKey(this.getSessionKey(chatId), this.profile))
             return false;
         const admissionEpoch = this.queueAdmissionEpoch.get(chatId) || 0;
         const snapshot = this.store.getInsertion(this.config.name, chatId, item.rowId);
@@ -1936,14 +2004,14 @@ export class FeishuBot {
             return (this.queueAdmissionEpoch.get(chatId) || 0) === admissionEpoch && this.stopGeneration(chatId) === epoch && saved.stopEpoch === epoch && JSON.stringify(now) === JSON.stringify(saved) &&
                 this.queueOwners.get(chatId) === local && (!local || local.batch === batch && local.runId === runId && (local.admitted === true || local.yielded === true) && local.collecting === true);
         };
-        const activity = await this.openclawClient.getSessionDispatchStatus?.(this.getSessionKey(chatId)).catch(() => null);
+        const activity = await this.openclawClient.getSessionDispatchStatus?.(this.physicalSessionKey(chatId)).catch(() => null);
         if (!unchanged() || !activity || activity.archived || activity.sessionId !== saved.sessionId)
             return false;
         if (activity.activeRunId === saved.runId)
             return false; // real foreground keeps SDK priority
         if (!activity.idleConfirmed && !activity.followupAdmissionEligible)
             return false;
-        const status = await this.openclawClient.getSessionRuntimeStatus(this.getSessionKey(chatId)).catch(() => null);
+        const status = await this.openclawClient.getSessionRuntimeStatus(this.physicalSessionKey(chatId)).catch(() => null);
         if (!unchanged() || !status || status.archived || status.sessionId !== saved.sessionId)
             return false;
         if (activity.activeRunId && activity.activeRunId !== saved.runId) {
@@ -1954,7 +2022,7 @@ export class FeishuBot {
             for (const item of this.store.listInsertions(this.config.name, chatId)) {
                 if (item.state !== 'pending' || item.attempted || item.noEffectRunId || item.ordinaryEligible === false || item.ownerId !== saved.id || item.batchId !== saved.batchId ||
                     item.stopEpoch !== epoch || item.sessionId !== saved.sessionId || !item.sessionKey ||
-                    canonicalPhysicalSessionKey(item.sessionKey) !== canonicalPhysicalSessionKey(this.getSessionKey(chatId)))
+                    canonicalPhysicalSessionKey(item.sessionKey, this.profile) !== canonicalPhysicalSessionKey(this.getSessionKey(chatId), this.profile))
                     continue;
                 const source = this.store.getMessageByMessageId(item.messageId);
                 if (source?.senderType !== 'human' || source.triggerKind !== 'normal')
@@ -1981,7 +2049,7 @@ export class FeishuBot {
         let followup;
         if (!idle || saved.followupAdmissionGuard) {
             const proof = this.observedFollowupGuard(chatId, status, activity);
-            if (!proof || !saved.sessionKey || canonicalPhysicalSessionKey(saved.sessionKey) !== proof.sessionKey)
+            if (!proof || !saved.sessionKey || canonicalPhysicalSessionKey(saved.sessionKey, this.profile) !== proof.sessionKey)
                 return false;
             const previous = saved.followupAdmissionGuard;
             if (previous && (previous.sessionKey !== proof.sessionKey || previous.sessionId !== proof.sessionId))
@@ -2014,7 +2082,12 @@ export class FeishuBot {
         }
     }
     stopGeneration(chatId) {
-        return this.stopEpoch.get(chatId) ?? this.store.getStopGeneration(this.config.name, chatId);
+        // A peer bot's group-scoped /stop bumps this bot's durable epoch. The
+        // in-memory value can then be stale and would mask the newer durable one,
+        // so take the greater of the two instead of trusting the cache blindly.
+        const cached = this.stopEpoch.get(chatId);
+        const stored = this.store.getStopGeneration(this.config.name, chatId);
+        return cached === undefined ? stored : Math.max(cached, stored);
     }
     reactionChecks = new Set();
     async receiptReaction(chatId, rowId, messageId, desired, runId = '') {
@@ -2249,7 +2322,7 @@ export class FeishuBot {
                         }
                         else {
                             state = 'pending';
-                            if (Date.now() - item.noEffectSince >= 60_000)
+                            if (Date.now() - item.noEffectSince >= this.unconfirmedGraceMs(chatId))
                                 this.explainUnconfirmedFollowup(chatId, item);
                         }
                     }
@@ -2267,7 +2340,7 @@ export class FeishuBot {
                     ordinaryEligible: receipt.ordinaryEligible, attempted: valid ? (receipt.attempted ?? true) : true, sessionId: item.sessionId, reason: receipt.reason, unknownChecks,
                     unknownSince: state === 'unknown' ? (item.state === 'unknown' && Number.isFinite(item.unknownSince) ? item.unknownSince : Date.now()) : undefined };
                 this.store.saveInsertion(this.config.name, chatId, item.rowId, item.insertionId, state, record, Date.now() + (state === 'unknown' ? 15_000 : 5000));
-                if (state === 'pending' && !record.attempted && Date.now() - (record.pendingSince || Date.now()) >= 60_000)
+                if (state === 'pending' && !record.attempted && Date.now() - (record.pendingSince || Date.now()) >= this.unconfirmedGraceMs(chatId))
                     this.explainUnconfirmedFollowup(chatId, record);
                 if (state === 'ordinary') {
                     this.store.deletePendingInsertionNotices(this.config.name, chatId, item.insertionId);
@@ -2323,7 +2396,7 @@ export class FeishuBot {
         return process.env.OPENCLAW_LARK_MULTI_AGENT_LIVE_STATUS !== "0";
     }
     async getUnhealthySessionStatus(chatId) {
-        const sessionKey = this.getSessionKey(chatId);
+        const sessionKey = this.physicalSessionKey(chatId);
         try {
             const resp = await this.openclawClient.getSessionInfo(sessionKey);
             const status = String(resp?.session?.status || "").toLowerCase();
@@ -2505,11 +2578,20 @@ export class FeishuBot {
      */
     forceExpireQueueOwner(chatId, reason, preserveDispatch = false) {
         const owner = this.queueRuns.get(chatId);
-        if (!owner)
+        if (!owner) {
+            // No local owner left, but a persisted dispatch_custody row may still
+            // exist for this chat (it is written before the owner is retired). The
+            // old early return stranded that row forever: it never became visible
+            // again, yet it also was never deleted. Clear it explicitly.
+            if (!preserveDispatch && this.store.clearDispatchCustodyForChat(this.config.name, chatId))
+                console.warn(`[${this.config.name}] cleared orphaned dispatch custody for ${chatId.slice(-8)}: ${reason}`);
             return false;
+        }
         const context = this.queueOwners.get(chatId);
         if (context?.batchId && !preserveDispatch)
             this.store.clearDispatchCustody(this.config.name, chatId, context.id, context.batchId);
+        else if (!preserveDispatch && !context)
+            this.store.clearDispatchCustodyForChat(this.config.name, chatId);
         if (context)
             context.revoked = true;
         this.busyChats.set(chatId, 0);
@@ -2731,7 +2813,11 @@ export class FeishuBot {
             const expectedIdentitySessionId = identityTargets[0]?.target.sessionId;
             try {
                 if (identityTargets.some(({ target }) => target.state !== 'bound' || !target.sessionId || target.sessionId !== expectedIdentitySessionId ||
-                    target.sessionKey !== this.getSessionKey(chatId) || (target.expiresAt ?? 0) <= Date.now()))
+                    // An identity target may hold the physical key (current records) or the
+                    // logical key (records written before profiles existed). Both denote
+                    // the SAME session, so both are accepted; comparing against only one
+                    // form would silently drop the message.
+                    (target.sessionKey !== this.physicalSessionKey(chatId) && target.sessionKey !== this.getSessionKey(chatId)) || (target.expiresAt ?? 0) <= Date.now()))
                     throw new SupersededObservation('retained original target unavailable');
                 sessionKey = await (expectedIdentitySessionId ? this.ensureSession(chatId, { sessionId: expectedIdentitySessionId, guard }) : this.ensureSession(chatId));
                 guard();
@@ -2893,7 +2979,10 @@ export class FeishuBot {
                             if (target?.triggerId === triggerId) {
                                 target.runId = runId;
                                 this.bindRunDeliveryTarget(chatId, runId, target);
-                                this.releaseRunDeliveryTargetAfter(chatId, runId, 30 * 60_000);
+                                // Result custody must outlive the real run. Observed GPT latency in a heavy
+                                // group reached ~59m40s, so a 30-minute release dropped a computed answer
+                                // that had no receiver left. Two hours covers the observed tail.
+                                this.releaseRunDeliveryTargetAfter(chatId, runId, 2 * 60 * 60_000);
                             }
                             // Refine state for logs/idempotent sync rows when OpenClaw returns
                             // a runId. markSubmittedBatch is idempotent due to local flags and
@@ -2961,7 +3050,7 @@ export class FeishuBot {
                     guard,
                     onSendAttempt: submissionId => {
                         guard();
-                        this.store.bindDeliveryRun(this.config.name, chatId, submissionId, { triggerId, messageId: lastHuman.messageId || '', runId: submissionId, stopGeneration: this.stopGeneration(chatId), sessionKey: `agent:main:${sessionKey.replace(/^agent:[^:]+:/, '')}` });
+                        this.store.bindDeliveryRun(this.config.name, chatId, submissionId, { triggerId, messageId: lastHuman.messageId || '', runId: submissionId, stopGeneration: this.stopGeneration(chatId), sessionKey: canonicalPhysicalSessionKey(sessionKey.replace(/^agent:[^:]+:/, ''), this.profile) });
                     },
                     onSubmitted: async (runId) => { guard(); const previousRoot = owner.runId; owner.runId = runId; foregroundRunId = runId; void this.queuedPresentations.advance(liveStatus, previousRoot, runId, owner.id, owner.batchId).catch(() => { }); this.bindRunDeliveryTarget(chatId, runId, { triggerId, messageId: lastHuman.messageId || "", liveStatus }); },
                 });
@@ -3050,7 +3139,6 @@ export class FeishuBot {
                                 // Mark every merged trigger only after receipt confirmation.
                                 for (const id of mergedTriggerIds)
                                     this.store.markDeliveredReply(this.config.name, chatId, id, lastHuman.messageId);
-                                void this.maybeAlertHighContext(chatId);
                             }
                             // Go supervision: record the delivered final reply as evidence and
                             // arm a debounced checker round (busy gates apply inside).
@@ -3115,6 +3203,10 @@ export class FeishuBot {
                     this.goController?.notifyRunOutcome(chatId, "no_reply", `trigger:${triggerId}`, "(本轮无用户可见回复 NO_REPLY)");
                 }
                 console.log(`[${this.config.name}] [${new Date().toISOString()}] ${shouldReply || hasAttachments ? 'Replied' : 'Skipped (empty/NO_REPLY)'} (${reply.length} chars, attachments=${parsedReply.attachments.length})`);
+                // Context usage is re-checked after EVERY completed message (delivered
+                // reply, NO_REPLY turn or runtime failure) and re-notifies each time while
+                // usage stays above the threshold.
+                await this.maybeAlertHighContext(chatId);
                 guard();
                 // Replace ack reactions with DONE only for trigger messages actually
                 // processed in this run. Queued messages that arrived mid-run keep their
@@ -3256,9 +3348,16 @@ export class FeishuBot {
                         await this.reconcileErrorNotices(chatId);
                         errorOutcomeConfirmed = this.store.findRunErrorOwner(this.config.name, chatId, p)?.status === 'delivered';
                     }
+                    else if (this.store.hasDeliveredReply(this.config.name, chatId, triggerId)) {
+                        // This trigger already received its visible reply. A later terminal
+                        // error for the same run must NOT contradict a delivered answer:
+                        // the user would see "did not complete" under their own answer.
+                        errorOutcomeConfirmed = true;
+                        console.warn(`[${this.config.name}] provider_error suppressed for ${chatId.slice(-8)} trigger=${triggerId}: reply already delivered`);
+                    }
                     else
                         await this.enqueueAndDispatchDelivery(chatId, "provider_error", `trigger:${triggerId}:provider-error`, errorText, [], lastHuman.messageId, `trigger:${triggerId}:provider-error`, undefined, foregroundRunId ? (() => {
-                            const p = this.scopeRunError(chatId, { sessionKey: `agent:main:${this.getSessionKey(chatId).replace(/^agent:[^:]+:/, '')}`, sessionId: owner.sessionId, runId: foregroundRunId, source: 'chat', state: 'error', detail: err instanceof Error ? err.message : undefined });
+                            const p = this.scopeRunError(chatId, { sessionKey: canonicalPhysicalSessionKey(this.getSessionKey(chatId), this.profile), sessionId: owner.sessionId, runId: foregroundRunId, source: 'chat', state: 'error', detail: err instanceof Error ? err.message : undefined });
                             return { sessionKey: p.sessionKey, sessionId: p.sessionId, runId: p.runId, error: p };
                         })() : undefined)
                             .then(outcome => {
@@ -3516,7 +3615,7 @@ export class FeishuBot {
     }
     async readSessionStatus(chatId) {
         try {
-            return await this.openclawClient.getSessionRuntimeStatus(this.getSessionKey(chatId));
+            return await this.openclawClient.getSessionRuntimeStatus(this.physicalSessionKey(chatId));
         }
         catch {
             return normalizeSessionRuntimeStatus(undefined);
@@ -3529,7 +3628,7 @@ export class FeishuBot {
     formatUserVisibleError(err, chatId) {
         if (err instanceof SessionWaitPaused)
             return err.message;
-        return formatProviderError(err, this.config.name, this.config.model, this.chatLocale(chatId));
+        return formatProviderError(err, this.config.name, this.config.model || "", this.chatLocale(chatId));
     }
     isBridgeControlReply(text) {
         const t = text.trim();
@@ -3614,36 +3713,34 @@ export class FeishuBot {
         }
     }
     /**
-     * After a reply is delivered, alert the user once if context usage crossed the
-     * threshold (default 80%), so they can compact before a session bloats into the
-     * timeout/lock/overflow failure modes. We only alert on a fresh crossing: once
-     * alerted we stay quiet until usage drops back below the threshold (e.g. after
-     * a compact), then re-arm.
+     * After a message completes, alert the user when context usage is at or above
+     * the threshold (default 80%), so they can compact before the session bloats
+     * into the timeout/lock/overflow failure modes.
+     *
+     * The check runs after EVERY completed message and re-notifies on every message
+     * while usage stays above the threshold. There is deliberately no per-chat
+     * "already warned" latch: with one, a single failed send (or a stale latch) would
+     * silently suppress every later warning, and the user would stop being told to
+     * compact while their context keeps growing.
      */
     async maybeAlertHighContext(chatId) {
         const threshold = contextAlertPct();
         if (threshold <= 0)
             return;
         try {
-            const sessionKey = this.getSessionKey(chatId);
+            const sessionKey = this.physicalSessionKey(chatId);
             const pct = await this.getContextUsagePercent(sessionKey);
-            if (pct <= 0)
+            if (pct <= 0 || pct < threshold)
                 return;
-            const alerted = this.contextAlerted.get(chatId) || false;
-            if (pct >= threshold) {
-                if (alerted)
-                    return; // already warned this cycle
-                this.contextAlerted.set(chatId, true);
-                const en = this.isEn(chatId);
-                const text = en
-                    ? `\u26a0\ufe0f Context is at ${pct}% (\u2265${threshold}%). Consider /compact soon to avoid timeouts/overflow.`
-                    : `\u26a0\ufe0f \u4e0a\u4e0b\u6587\u5df2\u8fbe ${pct}%\uff08\u2265${threshold}%\uff09\uff0c\u5efa\u8bae\u5c3d\u5feb /compact \u538b\u7f29\uff0c\u907f\u514d\u8d85\u65f6/\u7206\u4e0a\u4e0b\u6587\u3002`;
-                await this.sendMessage(chatId, text).catch(() => { });
-            }
-            else if (pct < threshold - 5) {
-                // Re-arm once usage clearly dropped (hysteresis to avoid flapping).
-                this.contextAlerted.set(chatId, false);
-            }
+            const en = this.isEn(chatId);
+            const text = en
+                ? `\u26a0\ufe0f Context is at ${pct}% (\u2265${threshold}%). Consider /compact soon to avoid timeouts/overflow.`
+                : `\u26a0\ufe0f \u4e0a\u4e0b\u6587\u5df2\u8fbe ${pct}%\uff08\u2265${threshold}%\uff09\uff0c\u5efa\u8bae\u5c3d\u5feb /compact \u538b\u7f29\uff0c\u907f\u514d\u8d85\u65f6/\u7206\u4e0a\u4e0b\u6587\u3002`;
+            // Best-effort: a failed alert must not block delivery, but it is logged so
+            // a persistently undelivered warning stays visible instead of silent.
+            await this.sendMessage(chatId, text).catch((err) => {
+                console.warn(`[${this.config.name}] high-context alert send failed for ${chatId.slice(-8)}: ${this.errorSummary(err)}`);
+            });
         }
         catch {
             // best-effort; never block delivery
@@ -3809,7 +3906,7 @@ export class FeishuBot {
         this.store.bindDeliveryRun(this.config.name, chatId, runId, { ...persisted, triggerId: target.triggerId, messageId: target.messageId, runId,
             sessionId: persisted?.sessionId || (owner?.runId === runId ? owner.sessionId : undefined),
             botIdentity: persisted?.botIdentity || this.config.appId, stopGeneration: persisted?.stopGeneration ?? this.stopGeneration(chatId),
-            sessionKey: persisted?.sessionKey || `agent:main:${this.getSessionKey(chatId).replace(/^agent:[^:]+:/, '')}` });
+            sessionKey: persisted?.sessionKey || canonicalPhysicalSessionKey(this.getSessionKey(chatId), this.profile) });
         this.deliveryTargetsByRun.set(key, {
             triggerId: target.triggerId,
             messageId: target.messageId,
@@ -3877,7 +3974,7 @@ export class FeishuBot {
         this.delayedFailureTimers.set(chatId, timer);
     }
     deliverySessionKey(chatId) {
-        return this.getSessionKey(chatId);
+        return this.physicalSessionKey(chatId);
     }
     stableHash(text) {
         let hash = 2166136261;
@@ -3896,7 +3993,7 @@ export class FeishuBot {
     }
     async enqueueAndDispatchDelivery(chatId, sourceType, sourceId, text, attachments = [], replyToMessageId, deliveryKey, finalReplyModel, provenance, errorNoticeId, completionTriggerIds) {
         if (provenance?.sessionKey && !/^agent:/.test(provenance.sessionKey))
-            provenance = { ...provenance, sessionKey: `agent:main:${provenance.sessionKey}` };
+            provenance = { ...provenance, sessionKey: canonicalPhysicalSessionKey(provenance.sessionKey, this.profile) };
         if (provenance?.sessionKey && provenance.runId && this.store.isStoppedObservation(provenance.sessionKey, provenance.runId))
             return { state: "suppressed", outboxIds: [] };
         if (text.trim().toUpperCase() === 'NO_REPLY')
@@ -4066,7 +4163,7 @@ export class FeishuBot {
         return this.store.getDeliveryDispatchOutcome(this.config.name, chatId, finalDeliveryKey);
     }
     scopeRunError(chatId, p) {
-        const key = /^agent:[^:]+:/.test(p.sessionKey) ? p.sessionKey : `agent:main:${p.sessionKey}`;
+        const key = canonicalPhysicalSessionKey(p.sessionKey, this.profile);
         const target = this.store.getDeliveryRunTarget(this.config.name, chatId, p.runId);
         const observation = this.store.getRunObservation(key, p.runId);
         // Pre-upgrade targets may lack app/physical fields. A known exact legacy
@@ -4091,7 +4188,7 @@ export class FeishuBot {
         const original = this.store.getDeliveryRunTarget(this.config.name, chatId, p.runId);
         if (original?.messageId && this.store.isMessageRecalled(original.messageId) ||
             original?.sessionId && p.sessionId && original.sessionId !== p.sessionId ||
-            original?.sessionKey && canonicalPhysicalSessionKey(original.sessionKey) !== canonicalPhysicalSessionKey(p.sessionKey))
+            original?.sessionKey && canonicalPhysicalSessionKey(original.sessionKey, this.profile) !== canonicalPhysicalSessionKey(p.sessionKey, this.profile))
             return 'original_error_target_revoked';
         const epoch = this.stopGeneration(chatId);
         if (p.botIdentity && p.botIdentity !== this.config.appId || original?.botIdentity && original.botIdentity !== this.config.appId ||
@@ -4377,7 +4474,7 @@ export class FeishuBot {
                 }
                 const notice = JSON.parse(item.deliveryMetaJson || '{}').insertionNotice;
                 if (notice) {
-                    const info = await this.openclawClient.getSessionInfo(this.getSessionKey(chatId), 1500).catch(() => null);
+                    const info = await this.openclawClient.getSessionInfo(this.physicalSessionKey(chatId), 1500).catch(() => null);
                     if (!this.insertionNoticeCurrent(chatId, notice) || info?.session?.archived === true ||
                         info?.session?.sessionId && info.session.sessionId !== notice.sessionId) {
                         this.store.markDeliveryFailed(item.id);
@@ -5901,7 +5998,7 @@ export class FeishuBot {
             return;
         }
         if (nextModel === this.config.model) {
-            await this.replyMessage(messageId, `🤖 ${this.config.name} 已经在使用：${this.config.model}`);
+            await this.replyMessage(messageId, `🤖 ${this.config.name} 已经在使用：${this.config.model || `profile ${this.profile}`}`);
             return;
         }
         if (!this.configPath) {
@@ -5932,7 +6029,7 @@ export class FeishuBot {
      * Handle /status command: show current session info.
      */
     async handleStatusCommand(chatId, chatType, messageId) {
-        const sessionKey = this.getSessionKey(chatId);
+        const sessionKey = this.physicalSessionKey(chatId);
         const chatInfo = this.store.getChatInfo(chatId);
         const msgCount = this.store.getMessageCount(chatId);
         let session = null;
@@ -6079,7 +6176,7 @@ export class FeishuBot {
         }
     }
     async handleCompactCommand(chatId, messageId, args = "") {
-        const sessionKey = this.getSessionKey(chatId);
+        const sessionKey = this.physicalSessionKey(chatId);
         const en = this.isEn(chatId);
         // Argument parsing — modes are strictly separated:
         //   /compact                 → transcript tail trim (default, model-free)
@@ -6180,7 +6277,7 @@ export class FeishuBot {
      * then verify via describe.
      */
     async handleResetCommand(chatId, messageId) {
-        const sessionKey = this.getSessionKey(chatId);
+        const sessionKey = this.physicalSessionKey(chatId);
         try {
             await this.assertIdentityEffect();
             // Go supervision: a reset replaces the executor session generation; pause
@@ -6203,7 +6300,7 @@ export class FeishuBot {
             await new Promise((r) => setTimeout(r, 2000));
             this.assertIdentityCurrent();
             // A held reset must not initialize an unobserved successor generation.
-            this.initializedSessions.delete(sessionKey);
+            this.initializedSessions.delete(this.getSessionKey(chatId));
             if (!held)
                 await this.ensureSession(chatId);
             await this.replyMessage(messageId, `✅ Session 已重置\n模型: ${this.config.model}`);
@@ -6217,8 +6314,42 @@ export class FeishuBot {
      * runs for the session, clears the busy lock and every pending trigger, and
      * resets stuck reactions so new messages are processed normally again.
      */
+    /** Release every peer bot's in-memory scheduling state for one chat.
+     * Each bot instance keeps its own queueRuns / queueOwners / busyChats /
+     * pendingAckMessages maps; a durable row cleanup cannot reach those. A
+     * group-scoped /stop must retire them too, otherwise the peer's queue owner
+     * survives and its next message is treated as "busy" forever. */
+    releasePeerBotsForChat(chatId) {
+        let released = 0;
+        for (const peer of Array.from(FeishuBot.allBots.values())) {
+            if (peer === this || peer.store !== this.store)
+                continue;
+            // Durable stop epoch was already bumped for this peer by the store-level
+            // group cleanup; mirror it into the peer's in-memory cache.
+            peer.stopEpoch.set(chatId, peer.store.getStopGeneration(peer.config.name, chatId));
+            peer.forceExpireQueueOwner(chatId, 'group-scoped stop by peer bot');
+            peer.busyChats.set(chatId, 0);
+            peer.admittedSteerAcks.delete(chatId);
+            peer.runFailureObservers.delete(chatId);
+            peer.queueRunTokens.delete(chatId);
+            const acks = peer.pendingAckMessages.get(chatId) || [];
+            peer.pendingAckMessages.set(chatId, []);
+            for (const ack of acks)
+                void peer.receiptReaction(chatId, ack.rowId, ack.messageId, '').catch(() => { });
+            // Fence the peer's stale collector so it cannot keep destructively
+            // consuming the replacement batch's frames from the shared session bucket.
+            try {
+                this.openclawClient.revokeSessionCollectors(peer.getSessionKey(chatId), 'group-scoped stop');
+            }
+            catch { /* isolated */ }
+            void peer.openclawClient.cancelSteerSession?.(peer.getSessionKey(chatId), peer.stopGeneration(chatId)).catch(() => { });
+            void peer.openclawClient.abortChat(peer.getSessionKey(chatId)).catch(() => { });
+            released++;
+        }
+        return released;
+    }
     async handleStopCommand(chatId, messageId) {
-        const sessionKey = this.getSessionKey(chatId);
+        const sessionKey = this.physicalSessionKey(chatId);
         // Go supervision: a user stop must also pause related Go, so the checker
         // cannot wake the just-stopped task back up with a follow-up.
         void this.goController?.pauseSilently(chatId, "用户执行了 /stop");
@@ -6243,14 +6374,29 @@ export class FeishuBot {
             this.pendingAckMessages.set(chatId, []);
             for (const ack of acks)
                 void this.receiptReaction(chatId, ack.rowId, ack.messageId, '').catch(() => { });
+            // Group scope: a bare /stop in a multi-bot group is executed by ONE bot,
+            // but every bot keeps its own pending_triggers / insertion_custody /
+            // dispatch_custody / reaction rows AND its own in-memory queue owner for
+            // this same chat. Stopping only the executing bot left the others
+            // believing the chat was busy, so their next message was queued and
+            // never dispatched. Release the whole chat for every peer bot.
+            //
+            // This MUST run BEFORE the abort RPC await: a user message that arrives
+            // while the abort is in flight has to survive the stop cutoff, exactly
+            // like the executing bot's own late input above.
+            const group = this.store.stopChatForAllBots(chatId, this.config.name);
+            const peers = this.releasePeerBotsForChat(chatId);
             await this.openclawClient.abortChat(sessionKey).catch(() => { });
             if (!this.queueRuns.has(chatId))
                 this.busyChats.set(chatId, 0);
             const locale = this.chatLocale(chatId);
+            const scopeNote = peers > 0
+                ? (locale === "en" ? ` Also released ${peers} peer bot(s) in this chat.` : ` 同时释放了本群其余 ${peers} 个 bot 的队列。`)
+                : "";
             await this.replyMessage(messageId, locale === "en"
-                ? `⏹️ Stopped. Aborted the active run, unlocked the queue, and cleared ${cleared} pending message(s). You can send a new message now.`
-                : `⏹️ 已停止。已中止当前 run、解锁队列，并清掉 ${cleared} 条待处理消息。现在可以重新发消息了。`);
-            console.log(`[${this.config.name}] /stop force-cleared ${chatId.slice(-8)}: aborted run, cleared ${cleared} pending`);
+                ? `⏹️ Stopped. Aborted the active run, unlocked the queue, and cleared ${cleared} pending message(s). You can send a new message now.${scopeNote}`
+                : `⏹️ 已停止。已中止当前 run、解锁队列，并清掉 ${cleared} 条待处理消息。现在可以重新发消息了。${scopeNote}`);
+            console.log(`[${this.config.name}] /stop force-cleared ${chatId.slice(-8)}: aborted run, cleared ${cleared} pending, group: insertions=${group.stoppedInsertions} triggers=${group.clearedTriggers} custody=${group.clearedCustody} peers=${peers}`);
         }
         catch (err) {
             await this.replyMessage(messageId, `❌ stop 失败: ${err.message}`);

package/dist/go-controller.d.ts

@@ -75,6 +75,8 @@ export type GoClient = {
 export type GoControllerDeps = {
     botName: string;
     fallbackModel: string;
+    /** OpenClaw profile that owns this bot's sessions (default "main"). */
+    profile?: string;
     store: import("./message-store.js").MessageStore;
     client: GoClient;
     /** Executor session key for a chat (e.g. lma-<bot>-<chatId>). */

package/dist/go-controller.js

@@ -1,5 +1,14 @@
 /** Independent LMA supervision. MessageStore owns objective, criteria and completion. */
 import { goSnapshotBlocked } from "./go-runtime-gate.js";
+/** Logical (profile-free) part of a session key. */
+const withoutAgentPrefix = (key) => key.replace(/^agent:[^:]+:/, '');
+/** Physical session key for a logical executor key under this bot's profile. */
+const physicalKey = (key, profile) => {
+    if (/^agent:[^:]+:/.test(key))
+        return key;
+    const agent = String(profile || "main").trim() || "main";
+    return `agent:${agent}:${key}`;
+};
 const CHECK_DELAY_MS = Number(process.env.OPENCLAW_LARK_MULTI_AGENT_GO_CHECK_DELAY_MS || 20000);
 const CHECKER_TIMEOUT_MS = Number(process.env.OPENCLAW_LARK_MULTI_AGENT_GO_CHECKER_TIMEOUT_MS || 10 * 60 * 1000);
 const MAX_CONTINUES = Number(process.env.OPENCLAW_LARK_MULTI_AGENT_GO_MAX_CONTINUES || 10);
@@ -120,7 +129,7 @@ export class GoController {
             const executor = sessionKey === job.executorSessionKey;
             const result = executor ? await client.collectGoExecutorRun({ runId: receipt.runId, sessionKey, sessionId: expectedSessionId, timeoutMs: CHECKER_TIMEOUT_MS }) : null;
             if (result && (result.runId !== receipt.runId || result.sessionId !== expectedSessionId ||
-                (result.sessionKey !== sessionKey && result.sessionKey !== `agent:main:${sessionKey}`)))
+                (result.sessionKey !== sessionKey && result.sessionKey !== physicalKey(sessionKey, this.d.profile))))
                 throw new Error("Executor result identity mismatch");
             const text = result ? result.text : await client.collectGoRun({ runId: receipt.runId, sessionKey, sessionId: expectedSessionId, timeoutMs: CHECKER_TIMEOUT_MS });
             this.d.store.recordGoRunResult(jobId, actionKey, { state: "complete", runId: receipt.runId, text, ...(result ? { executorResult: result } : {}) });
@@ -204,7 +213,10 @@ export class GoController {
             await this.d.reply(messageId, `⚠️ 当前已有活动 Go #${existing.id}：\n目标：${existing.goal.slice(0, 200)}\n如需更换目标，请先 /go stop。`);
             return;
         }
-        const executorKey = this.d.executorSessionKeyFor(chatId);
+        // The Go supervision path talks to the Gateway directly, so it uses the
+        // PHYSICAL key throughout (profile included) exactly like the executor
+        // session itself.
+        const executorKey = physicalKey(this.d.executorSessionKeyFor(chatId), this.d.profile);
         if (await this.safetyUnavailable(executorKey)) {
             await this.d.reply(messageId, "❌ Go 未启动：当前运行时尚未验证 Checker 工具隔离、精确子孙任务/投递门禁及条件发送。不能仅凭提示词安全开启自动监督。独立模式无需原生 Goal；普通聊天不受影响。");
             return;
@@ -230,7 +242,10 @@ export class GoController {
             || (typeof session.model === "string" && session.model
                 ? (typeof session.modelProvider === "string" && session.modelProvider && !session.model.includes("/") ? `${session.modelProvider}/${session.model}` : session.model)
                 : this.d.fallbackModel);
-        const checkerKey = `${executorKey.replace(/^lma-/, "lma-go-")}-${crypto.randomUUID()}`;
+        // The checker session NAME stays profile-free (lma- -> lma-go-), exactly like
+        // every other logical key LMA stores. It is addressed under the bot's
+        // profile only when it is actually handed to the Gateway.
+        const checkerKey = physicalKey(`${withoutAgentPrefix(executorKey).replace(/^lma-/, "lma-go-")}-${crypto.randomUUID()}`, this.d.profile);
         try {
             await this.d.client.createSession({ key: checkerKey, model: resolvedModel, label: `Go Checker: ${this.d.botName} ${chatId.slice(-6)}` });
         }
@@ -349,7 +364,7 @@ export class GoController {
                     if (saved?.state !== "complete") {
                         const result = await this.d.client.readGoExecutorRunResult?.({ ...send, runId: receipt.runId });
                         if (!result || result.runId !== receipt.runId || result.sessionId !== job.executorSessionId ||
-                            ![job.executorSessionKey, `agent:main:${job.executorSessionKey}`].includes(result.sessionKey)) {
+                            ![job.executorSessionKey, physicalKey(job.executorSessionKey, this.d.profile)].includes(result.sessionKey)) {
                             this.d.store.recordGoRunResult(job.id, send.actionKey, { state: "unknown", runId: receipt.runId });
                             continue;
                         }
@@ -510,16 +525,17 @@ export class GoController {
     // ---------------- check cycle ----------------
     async executorBusy(chatId, job) {
         try {
-            if (await this.safetyUnavailable(job.executorSessionKey))
+            const executorPhysicalKey = job.executorSessionKey;
+            if (await this.safetyUnavailable(executorPhysicalKey))
                 return "运行时安全能力未验证";
-            const info = await (this.d.client.getGoSessionInfo?.bind(this.d.client) ?? this.d.client.getSessionInfo.bind(this.d.client))(job.executorSessionKey);
+            const info = await (this.d.client.getGoSessionInfo?.bind(this.d.client) ?? this.d.client.getSessionInfo.bind(this.d.client))(executorPhysicalKey);
             if (info?.session?.sessionId !== job.executorSessionId || info?.session?.archived)
                 return "执行会话代际已改变或归档";
             const identity = this.d.store.getGoNativeIdentity(job.id);
             if (!identity)
                 return "Missing independent run binding";
-            const snapshot = await this.d.client.readGoRuntimeSnapshot(job.executorSessionKey, job.executorSessionId);
-            const blocked = goSnapshotBlocked(snapshot, { sessionKey: job.executorSessionKey.startsWith("agent:") ? job.executorSessionKey : `agent:main:${job.executorSessionKey}`, sessionId: job.executorSessionId,
+            const snapshot = await this.d.client.readGoRuntimeSnapshot(executorPhysicalKey, job.executorSessionId);
+            const blocked = goSnapshotBlocked(snapshot, { sessionKey: executorPhysicalKey, sessionId: job.executorSessionId,
                 goalId: identity.nativeGoalId, goalRevision: identity.goalRevision, executorRunIds: identity.executorRunIds });
             if (blocked) {
                 if (blocked === "identity/version changed")

package/dist/message-store.d.ts

@@ -171,7 +171,7 @@ export declare class MessageStore {
     recoverUnsentReservations(bot: string): number;
     saveAdmission(sessionKey: string, submissionId: string, state: string, record: object): void;
     listAdmissions(sessionKey: string): any[];
-    stopExactRun(sessionKey: string, runId: string): void;
+    stopExactRun(sessionKey: string, runId: string, userStopped?: boolean): void;
     isStoppedObservation(sessionKey: string, runId: string): boolean;
     hasUnconfirmedRunDelivery(bot: string, chat: string, runId: string): boolean;
     /** UI-only witness of an exact run's visible reply in the original Bot/chat.
@@ -190,6 +190,27 @@ export declare class MessageStore {
     hasYieldedObservation(sessionKey: string): boolean;
     getRunObservation(sessionKey: string, runId: string): any;
     runObservationState(sessionKey: string, runId: string): string | undefined;
+    /** Observed reply latency for this chat, from real delivered replies.
+     *
+     * Used to size the "input still unconfirmed" window. A fixed short timer
+     * misfired on slow sessions where nearly every legitimate reply took longer
+     * than the timer, producing a false "not confirmed" notice for a run that
+     * was in fact progressing normally. Returns null when there is no history. */
+    observedReplyLatencyMs(bot: string, chat: string): number | null;
+    /** True only when THIS run was explicitly stopped by the user.
+     *
+     * Distinct from a retired observation: a group /stop retires every bot's
+     * observation on the shared session, which is NOT a user request to kill
+     * each individual run. */
+    isExplicitlyStoppedObservation(sessionKey: string, runId: string): boolean;
+    /** Retire session-scoped observation, but NEVER a run whose committed
+     * terminal reply has already been observed.
+     *
+     * A run with terminalObserved=true holds a COMPUTED answer. Retiring its
+     * observation (via /stop, /reset or an abort) removes the only durable
+     * custody that answer has, so recoverExactRuns can never deliver it and the
+     * computed reply is silently lost. A run without a terminal observation has
+     * nothing to deliver yet and may be retired normally. */
     stopSessionObservations(sessionKey: string): void;
     settleExactRunReactions(sessionKey: string, runId: string): void;
     finishRunObservation(sessionKey: string, runId: string, state?: string): void;
@@ -211,6 +232,23 @@ export declare class MessageStore {
     isInsertionReserved(bot: string, chat: string, row: number): boolean;
     stopInsertionAtEpoch(bot: string, chat: string, row: number, epoch: number): void;
     stopInsertions(bot: string, chat: string): void;
+    /** Group-scoped stop cleanup: every bot in this chat, not just the caller.
+     * A bare /stop in a multi-bot group is executed by ONE bot, but each bot keeps
+     * its own pending_triggers / insertion_custody / dispatch_custody / reaction
+     * rows for the same chat. Stopping only the executing bot left the others
+     * believing the chat was still busy, so their next message was queued and
+     * never dispatched. */
+    stopChatForAllBots(chat: string, exceptBot?: string): {
+        stoppedInsertions: number;
+        clearedTriggers: number;
+        clearedCustody: number;
+    };
+    /** Same predicate as stopInsertions, but reports how many rows it retired. */
+    stopInsertionsCount(bot: string, chat: string): number;
+    /** Drop a bot's dispatch custody for a chat regardless of owner/batch
+     * identity. forceExpireQueueOwner can no-op when the local queue owner is
+     * already gone, which used to strand the row forever. */
+    clearDispatchCustodyForChat(bot: string, chat: string): number;
     hasUnknownDeliveryOperation(outbox: number): boolean;
     /** Includes non-visible uploads/doc creation: absence of a message_id is
      * not proof that no SDK effect has been attempted or accepted. */

package/dist/message-store.js

@@ -258,9 +258,10 @@ export class MessageStore {
     listAdmissions(sessionKey) {
         return this.db.prepare('SELECT * FROM admission_custody WHERE session_key=? ORDER BY rowid DESC LIMIT 100').all(sessionKey).map(r => ({ ...JSON.parse(r.record_json), submissionId: r.submission_id, state: r.state }));
     }
-    stopExactRun(sessionKey, runId) {
-        this.db.prepare(`INSERT INTO run_observations VALUES(?,?,'{}','stopped',0)
-      ON CONFLICT(session_key,run_id) DO UPDATE SET state='stopped'`).run(sessionKey, runId);
+    stopExactRun(sessionKey, runId, userStopped = false) {
+        const record = userStopped ? { userStopped: true } : {};
+        this.db.prepare(`INSERT INTO run_observations VALUES(?,?,?,'stopped',0)
+      ON CONFLICT(session_key,run_id) DO UPDATE SET state='stopped', record_json=json_patch(run_observations.record_json,excluded.record_json)`).run(sessionKey, runId, JSON.stringify(record));
     }
     isStoppedObservation(sessionKey, runId) {
         return !!this.db.prepare("SELECT 1 FROM run_observations WHERE session_key=? AND run_id=? AND state='stopped'").get(sessionKey, runId);
@@ -329,8 +330,45 @@ export class MessageStore {
     runObservationState(sessionKey, runId) {
         return this.db.prepare('SELECT state FROM run_observations WHERE session_key=? AND run_id=?').get(sessionKey, runId)?.state;
     }
+    /** Observed reply latency for this chat, from real delivered replies.
+     *
+     * Used to size the "input still unconfirmed" window. A fixed short timer
+     * misfired on slow sessions where nearly every legitimate reply took longer
+     * than the timer, producing a false "not confirmed" notice for a run that
+     * was in fact progressing normally. Returns null when there is no history. */
+    observedReplyLatencyMs(bot, chat) {
+        // p90 over real delivered replies. MAX would be dominated by a single
+        // pathological outlier and inflate the window for every later request.
+        const sql = "SELECT (d.delivered_at - m.timestamp) AS lat FROM delivered_replies d" +
+            " JOIN messages m ON m.id=d.trigger_message_row_id" +
+            " WHERE d.bot_name=? AND d.chat_id=? AND d.delivered_at > m.timestamp AND m.timestamp > 0" +
+            " ORDER BY d.delivered_at DESC LIMIT 30";
+        const rows = this.db.prepare(sql).all(bot, chat);
+        const lats = rows.map(r => Number(r.lat)).filter(x => Number.isFinite(x) && x > 0).sort((a, b) => a - b);
+        if (!lats.length)
+            return null;
+        const p90 = lats[Math.min(lats.length - 1, Math.floor(lats.length * 0.9))];
+        return Number.isFinite(p90) && p90 > 0 ? p90 : null;
+    }
+    /** True only when THIS run was explicitly stopped by the user.
+     *
+     * Distinct from a retired observation: a group /stop retires every bot's
+     * observation on the shared session, which is NOT a user request to kill
+     * each individual run. */
+    isExplicitlyStoppedObservation(sessionKey, runId) {
+        const row = this.db.prepare("SELECT 1 FROM run_observations WHERE session_key=? AND run_id=? AND state='stopped' AND json_extract(record_json,'$.userStopped')=1").get(sessionKey, runId);
+        return !!row;
+    }
+    /** Retire session-scoped observation, but NEVER a run whose committed
+     * terminal reply has already been observed.
+     *
+     * A run with terminalObserved=true holds a COMPUTED answer. Retiring its
+     * observation (via /stop, /reset or an abort) removes the only durable
+     * custody that answer has, so recoverExactRuns can never deliver it and the
+     * computed reply is silently lost. A run without a terminal observation has
+     * nothing to deliver yet and may be retired normally. */
     stopSessionObservations(sessionKey) {
-        this.db.prepare("UPDATE run_observations SET state='stopped' WHERE session_key=? AND state IN ('observing','outbox_owned')").run(sessionKey);
+        this.db.prepare("UPDATE run_observations SET state='stopped' WHERE session_key=? AND state IN ('observing','outbox_owned') AND json_extract(record_json,'$.terminalObserved') IS NOT 1").run(sessionKey);
     }
     settleExactRunReactions(sessionKey, runId) {
         const targets = this.db.prepare('SELECT bot_name,chat_id FROM run_delivery_targets WHERE run_id=?').all(runId);
@@ -406,6 +444,45 @@ export class MessageStore {
     stopInsertions(bot, chat) {
         this.db.prepare("UPDATE insertion_custody SET state='stopped' WHERE bot_name=? AND chat_id=? AND (state NOT IN ('committed','ordinary') OR state='ordinary' AND json_type(record_json,'$.followupAdmissionGuard')='object')").run(bot, chat);
     }
+    /** Group-scoped stop cleanup: every bot in this chat, not just the caller.
+     * A bare /stop in a multi-bot group is executed by ONE bot, but each bot keeps
+     * its own pending_triggers / insertion_custody / dispatch_custody / reaction
+     * rows for the same chat. Stopping only the executing bot left the others
+     * believing the chat was still busy, so their next message was queued and
+     * never dispatched. */
+    stopChatForAllBots(chat, exceptBot) {
+        const bots = this.db.prepare("SELECT DISTINCT bot_name FROM pending_triggers WHERE chat_id=? UNION SELECT DISTINCT bot_name FROM insertion_custody WHERE chat_id=? UNION SELECT DISTINCT bot_name FROM dispatch_custody WHERE chat_id=? UNION SELECT DISTINCT bot_name FROM reaction_custody WHERE chat_id=?").all(chat, chat, chat, chat).map((r) => r.bot_name);
+        let stoppedInsertions = 0, clearedTriggers = 0, clearedCustody = 0;
+        for (const bot of bots) {
+            if (bot === exceptBot) {
+                // The executing bot already bumped its own epoch and cancelled its own
+                // reaction intents; touching them again would desynchronize its
+                // in-memory generation from the durable one.
+                stoppedInsertions += this.stopInsertionsCount(bot, chat);
+                clearedTriggers += this.clearAllPendingTriggers(bot, chat);
+                clearedCustody += this.clearDispatchCustodyForChat(bot, chat);
+                continue;
+            }
+            // Invalidate every epoch-scoped record for this bot/chat: a stale
+            // dispatch_custody with an old stopEpoch can never be released later.
+            this.bumpStopGeneration(bot, chat);
+            this.cancelReactionIntents(bot, chat, this.getStopGeneration(bot, chat));
+            stoppedInsertions += this.stopInsertionsCount(bot, chat);
+            clearedTriggers += this.clearAllPendingTriggers(bot, chat);
+            clearedCustody += this.clearDispatchCustodyForChat(bot, chat);
+        }
+        return { stoppedInsertions, clearedTriggers, clearedCustody };
+    }
+    /** Same predicate as stopInsertions, but reports how many rows it retired. */
+    stopInsertionsCount(bot, chat) {
+        return this.db.prepare("UPDATE insertion_custody SET state='stopped' WHERE bot_name=? AND chat_id=? AND (state NOT IN ('committed','ordinary') OR state='ordinary' AND json_type(record_json,'$.followupAdmissionGuard')='object')").run(bot, chat).changes;
+    }
+    /** Drop a bot's dispatch custody for a chat regardless of owner/batch
+     * identity. forceExpireQueueOwner can no-op when the local queue owner is
+     * already gone, which used to strand the row forever. */
+    clearDispatchCustodyForChat(bot, chat) {
+        return this.db.prepare("DELETE FROM dispatch_custody WHERE bot_name=? AND chat_id=?").run(bot, chat).changes;
+    }
     hasUnknownDeliveryOperation(outbox) {
         return !!this.db.prepare(`SELECT 1 FROM delivery_operations o WHERE outbox_id=? AND state IN ('attempted','unknown')
       AND NOT EXISTS(SELECT 1 FROM delivery_receipt_custody k WHERE k.outbox_id=o.outbox_id AND k.operation_key=o.operation_key) LIMIT 1`).get(outbox);

package/dist/openclaw-client.d.ts

@@ -72,10 +72,6 @@ export type ChatAttachment = {
 };
 export declare const GATEWAY_PROTOCOL_MIN = 4;
 export declare const GATEWAY_PROTOCOL_MAX = 4;
-/**
- * OpenClaw Gateway WebSocket client.
- * Full agent pipeline — tools, memory, skills, context management by OpenClaw.
- */
 export declare class OpenClawClient {
     private goEvidenceObservers;
     /** Raw full event observer. Observation is NOT a Feishu delivery receipt. */

package/dist/openclaw-client.js

@@ -80,6 +80,15 @@ const terminalReason = (...values) => values.map(closedStopReason).sort((a, b) =
  * OpenClaw Gateway WebSocket client.
  * Full agent pipeline — tools, memory, skills, context management by OpenClaw.
  */
+/** Physical session key for a logical key.
+ *
+ * A key that already carries an explicit `agent:<id>:` prefix keeps it, so a
+ * client shared by several bots can serve sessions owned by different
+ * OpenClaw profiles. A key without a prefix stays on the historical `main`
+ * profile, so existing configurations behave exactly as before. */
+const withAgentPrefix = (key) => /^agent:[^:]+:/.test(key) ? key : `agent:main:${key}`;
+/** Logical (profile-free) part of a session key. */
+const withoutAgentPrefix = (key) => key.replace(/^agent:[^:]+:/, '');
 export class OpenClawClient {
     goEvidenceObservers = new Set();
     /** Raw full event observer. Observation is NOT a Feishu delivery receipt. */
@@ -153,7 +162,11 @@ export class OpenClawClient {
     isExplicitlyStoppedRun(sessionKey, runId) {
         if (!runId)
             return false;
-        if (this.recoveryStore?.isStoppedObservation(this.canonicalSessionKey(sessionKey), runId))
+        // A retired observation is NOT the same as a user-requested stop. A bare
+        // /stop in a multi-bot group retires EVERY bot's observation on the shared
+        // session; treating that retirement as "the user stopped this run"
+        // discarded answers the Gateway had already computed.
+        if (this.recoveryStore?.isExplicitlyStoppedObservation(this.canonicalSessionKey(sessionKey), runId))
             return true;
         const key = JSON.stringify([this.canonicalSessionKey(sessionKey), runId]);
         const at = this.explicitlyStoppedRuns.get(key);
@@ -1255,7 +1268,7 @@ export class OpenClawClient {
             // tripping the disconnect path.
             const startedConnected = this.connected;
             let chatFinalText = "";
-            let sessionKey = targetSessionKey ? `agent:main:${targetSessionKey.replace(/^agent:[^:]+:/, "")}` : "";
+            let sessionKey = targetSessionKey ? withAgentPrefix(targetSessionKey) : "";
             let shortSessionKey = targetSessionKey ? targetSessionKey.replace(/^agent:[^:]+:/, "") : "";
             let chatFinalTimer = null;
             let lifecycleEndTimer = null;
@@ -2227,7 +2240,7 @@ export class OpenClawClient {
         return sessionKey.replace(/^agent:[^:]+:/, "");
     }
     canonicalSessionKey(sessionKey) {
-        return /^agent:[^:]+:/.test(sessionKey) ? sessionKey : `agent:main:${sessionKey}`;
+        return withAgentPrefix(sessionKey);
     }
     registerPendingSteer(sessionKey, text, displayText) {
         const key = this.shortKey(sessionKey);
@@ -2533,7 +2546,7 @@ export class OpenClawClient {
             const message = firstErr.message || String(firstErr);
             if (!/session (?:not found|unknown)|unknown session|invalid session key/i.test(message))
                 throw firstErr;
-            const fullKey = sessionKey.startsWith("agent:") ? sessionKey : `agent:main:${sessionKey}`;
+            const fullKey = withAgentPrefix(sessionKey);
             held?.guard();
             await this.patchSession({ key: fullKey, model: expectedModel, ...(held ? { expectedSessionId: held.sessionId } : {}) });
         }
@@ -2743,7 +2756,7 @@ export class OpenClawClient {
                 for (const stopped of result.runIds)
                     if (typeof stopped === "string" && stopped) {
                         this.explicitlyStoppedRuns.set(JSON.stringify([key, stopped]), Date.now());
-                        this.recoveryStore?.stopExactRun(key, stopped);
+                        this.recoveryStore?.stopExactRun(key, stopped, true);
                     }
             }
             return result;
@@ -2978,8 +2991,8 @@ export class OpenClawClient {
         }
     }
     muteProactiveDelivery(sessionKey) {
-        const shortKey = sessionKey.startsWith("agent:main:") ? sessionKey.slice("agent:main:".length) : sessionKey;
-        const fullKey = `agent:main:${shortKey}`;
+        const shortKey = withoutAgentPrefix(sessionKey);
+        const fullKey = withAgentPrefix(sessionKey);
         const keys = [shortKey, fullKey];
         for (const key of keys)
             this.addMutedProactiveKey(key);
@@ -3642,7 +3655,7 @@ export class OpenClawClient {
         if (onSettled)
             this.sessionSettlementCallbacks.set(this.canonicalSessionKey(sessionKey), onSettled);
         this.sessionMessageCallbacks.set(sessionKey, onMessage);
-        this.sessionMessageCallbacks.set(`agent:main:${sessionKey}`, onMessage);
+        this.sessionMessageCallbacks.set(withAgentPrefix(sessionKey), onMessage);
         this.subscribedKeys.add(sessionKey);
         try {
             await this.rpc("sessions.messages.subscribe", { key: this.canonicalSessionKey(sessionKey) });
@@ -3652,7 +3665,7 @@ export class OpenClawClient {
         }
     }
     setVerboseTranscriptDelivery(sessionKey, enabled) {
-        const keys = [sessionKey, `agent:main:${sessionKey}`];
+        const keys = [sessionKey, withAgentPrefix(sessionKey)];
         for (const key of keys) {
             if (enabled)
                 this.verboseTranscriptSessions.add(key);
@@ -3665,9 +3678,9 @@ export class OpenClawClient {
     async unsubscribeSession(sessionKey) {
         this.sessionSettlementCallbacks.delete(this.canonicalSessionKey(sessionKey));
         this.sessionMessageCallbacks.delete(sessionKey);
-        this.sessionMessageCallbacks.delete(`agent:main:${sessionKey}`);
+        this.sessionMessageCallbacks.delete(withAgentPrefix(sessionKey));
         this.toolEventCallbacks.delete(sessionKey);
-        this.toolEventCallbacks.delete(`agent:main:${sessionKey}`);
+        this.toolEventCallbacks.delete(withAgentPrefix(sessionKey));
         this.setVerboseTranscriptDelivery(sessionKey, false);
         this.subscribedKeys.delete(sessionKey);
         try {
@@ -3682,6 +3695,6 @@ export class OpenClawClient {
      */
     onToolEvent(sessionKey, callback) {
         this.toolEventCallbacks.set(sessionKey, callback);
-        this.toolEventCallbacks.set(`agent:main:${sessionKey}`, callback);
+        this.toolEventCallbacks.set(withAgentPrefix(sessionKey), callback);
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openclaw-lark-multi-agent",
-  "version": "1.8.20",
+  "version": "1.8.21",
   "description": "Multi-bot Lark/Feishu bridge for OpenClaw, with per-bot model routing and isolated sessions",
   "type": "module",
   "scripts": {
@@ -89,4 +89,4 @@
   "publishConfig": {
     "access": "public"
   }
-}
+}