openclaw-lark-multi-agent 1.2.7 → 1.2.8

package/dist/feishu-bot.js

@@ -1119,6 +1119,13 @@ export class FeishuBot {
             const isNativeCommandTrigger = firstIsNative;
             const lastHuman = mergedTriggers[mergedTriggers.length - 1];
             const triggerId = lastHuman.id || 0;
+            // Snapshot the stop generation BEFORE the main run starts. If the user runs
+            // /stop at any point during the main run, handleStopCommand bumps the epoch;
+            // auto-retry compares against this baseline and skips retrying entirely. If
+            // we snapshotted inside auto-retry instead, a /stop that landed during the
+            // main run would already be baked into the baseline and go undetected —
+            // that was the "stop then auto-retry anyway" bug.
+            const runStartStopEpoch = this.stopEpoch.get(chatId) || 0;
             const mergedContent = mergedTriggers.map((m) => m.content).join("\n");
             const mergedTriggerIds = mergedTriggers.map((m) => m.id || 0).filter(Boolean);
             const droppedTriggerIds = droppedMergedTriggers.map((m) => m.id || 0).filter(Boolean);
@@ -1267,6 +1274,7 @@ export class FeishuBot {
                     isNativeCommandTrigger,
                     initialReply: reply,
                     liveStatus,
+                    runStartStopEpoch,
                 });
                 const parsedReply = this.extractBridgeAttachments(reply);
                 const visibleReply = parsedReply.text;
@@ -1780,10 +1788,12 @@ export class FeishuBot {
         if (!autoRetryEnabled() || isNativeCommandTrigger)
             return reply;
         const maxRetry = autoRetryMax();
-        // Snapshot the stop generation at entry. If the user runs /stop while this
-        // loop is in flight, handleStopCommand bumps the epoch; we detect the change
-        // and stop retrying immediately instead of issuing more probes.
-        const startStopEpoch = this.stopEpoch.get(chatId) || 0;
+        // Baseline stop generation. Prefer the epoch captured before the main run
+        // (runStartStopEpoch) so a /stop that landed DURING the main run is still
+        // seen here; fall back to the current epoch only if the caller did not pass
+        // one. If the user hit /stop at any point from the main run onward, the
+        // epoch is now past the baseline and we must not auto-retry at all.
+        const startStopEpoch = params.runStartStopEpoch ?? (this.stopEpoch.get(chatId) || 0);
         const wasStopped = () => (this.stopEpoch.get(chatId) || 0) !== startStopEpoch;
         for (let attempt = 1; attempt <= maxRetry; attempt++) {
             // /stop while we were looping: abandon retries and deliver what we have.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openclaw-lark-multi-agent",
-  "version": "1.2.7",
+  "version": "1.2.8",
   "description": "Multi-bot Lark/Feishu bridge for OpenClaw, with per-bot model routing and isolated sessions",
   "type": "module",
   "scripts": {