@songsid/agend 2.1.7-beta.5 → 2.1.7-beta.7

package/dist/fleet-manager.js

@@ -16,17 +16,7 @@ const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 /** Fallback access policy for a channel with no `access:` block — open (no gate). */
 const DEFAULT_OPEN_ACCESS = { mode: "open", allowed_users: [], max_pending_codes: 0, code_expiry_minutes: 0 };
-/**
- * Telegram bot reactions replace a single slot per message. Keep delivery state
- * presentation here so supported emoji choices can change without altering the
- * status reconciliation logic.
- */
-const TELEGRAM_DELIVERY_STATUS_REACTIONS = new Map([
-    ["👀", "👀"], // queued / processing
-    ["⏳", "👀"],
-    ["✅", "👀"], // confirmed
-    ["❌", "👎"], // failed
-]);
+import { STATUS_EMOJI_KEYS, builtinStatusEmojis, reactionForm, reactionMatchKey, resolveStatusEmojis, statusAvoidList, statusMatchKey, statusMatchKeys, textForm, } from "./status-emojis.js";
 import { isProbeableRouteTarget } from "./fleet-context.js";
 import { loadFleetConfig, loadRawFleetConfig, DEFAULT_COST_GUARD, DEFAULT_DAILY_SUMMARY, DEFAULT_INSTANCE_CONFIG } from "./config.js";
 import { EventLog } from "./event-log.js";
@@ -196,19 +186,10 @@ const TOOL_PROGRESS_EDIT_MIN_MS = 4_000;
 const PROGRESS_MIN_ELAPSED_MS = 30_000;
 /** How much of a tool summary the progress line will show before eliding. */
 const PROGRESS_ACTIVITY_MAX_CHARS = 48;
-/**
- * Emoji AgEnD itself stamps on messages as the delivery-status ladder
- * (⏳ queued, 👀 delivered, ✅ confirmed, ❌ failed). These are machine
- * indicators, not opinions, so they never enter the reactions queue — from
- * anyone. This exact-emoji filter is the ONLY bot filtering left: bot-to-bot
- * reactions are otherwise delivered on purpose (agents signal each other), and
- * 🫡 passes too — it reads as a deliberate acknowledgement, not plumbing.
- */
-const DELIVERY_STATUS_EMOJIS = new Set(["👀", "⏳", "✅", "❌"]);
 /**
  * Reactions that are neither delivery plumbing nor meaningful conversational
- * feedback. Keep this separate from DELIVERY_STATUS_EMOJIS so adding a UI-only
- * emoji never changes the documented delivery-state protocol.
+ * feedback. Delivery-status emojis are configurable (#1005) and filtered by
+ * FleetManager.isOwnStatusReaction, not by a fixed set.
  */
 const IGNORED_REACTION_EMOJIS = new Set(["📷"]);
 /**
@@ -286,6 +267,10 @@ export function deriveSpawnConcurrency(freeMemMB, cores) {
     const byMemory = Math.floor(freeMemMB / 300);
     return Math.max(2, Math.min(10, byMemory, Math.max(1, cores)));
 }
+/** #926: how often reply obligations are checked, the owner-reminder grace, and the default overdue window. */
+const REPLY_OBLIGATION_SWEEP_MS = 30_000;
+const REPLY_REMINDER_GRACE_MS = 60_000;
+const DEFAULT_REPLY_OVERDUE_MINUTES = 15;
 export class FleetManager {
     dataDir;
     static signalTarget = null;
@@ -303,6 +288,8 @@ export class FleetManager {
     deliveryPumpScheduled = false;
     deliveryPumpRunning = false;
     deliveryPumpTimer = null;
+    /** #926: periodic reply-obligation sweep (owner reminders, requester overdue notices). */
+    replyObligationTimer = null;
     activeDurableTargets = new Set();
     /** Live view of lifecycle.daemons — used throughout; not deprecated. */
     get daemons() { return this.lifecycle.daemons; }
@@ -595,6 +582,14 @@ export class FleetManager {
             }
         });
         outbox.on("generation_recovered", () => this.scheduleDeliveryOutboxPump());
+        this.replyObligationTimer = setInterval(() => this.sweepReplyObligations(), REPLY_OBLIGATION_SWEEP_MS);
+        this.replyObligationTimer.unref?.();
+        // #856: the text the target daemon received differs from what was
+        // admitted. Transport has never been seen to do this; a warning and the
+        // attempt row's flag are the whole response until it has.
+        outbox.on("content_digest_mismatch", (event) => {
+            this.logger.warn(event, "Delivered text differs from the admitted text (content digest mismatch)");
+        });
         outbox.on("expired", (event) => {
             this.scheduleDeliveryOutboxPump();
             if (event.count)
@@ -652,8 +647,38 @@ export class FleetManager {
                 this.logger.error({ err, source: name, operationId: prior.operationId }, "Could not persist post-restart delivery outcome notice");
             }
         }
+        // #926: a restart kills the turn that was working on a request, and a
+        // resumed CLI does not pick it back up. Remind the owner once per restart.
+        try {
+            outbox.remindReplyObligations(name, { reason: "restart", graceMs: 0, since: new Date() });
+        }
+        catch (err) {
+            this.logger.error({ err, owner: name }, "Could not persist the post-restart reply reminder");
+        }
         this.scheduleDeliveryOutboxPump();
     }
+    /**
+     * #926: the two reply-obligation safety nets. Idle owners with an unanswered
+     * request get one reminder (after the grace); requesters get one overdue
+     * notice when the owner is not working and nothing came back in time.
+     */
+    sweepReplyObligations(now = new Date()) {
+        const outbox = this.deliveryOutbox;
+        if (!outbox || this.shuttingDown)
+            return;
+        const stateOf = (name) => this.daemons.get(name)?.getInstanceState();
+        try {
+            for (const name of this.daemons.keys()) {
+                if (stateOf(name) === "idle")
+                    outbox.remindReplyObligations(name, { now, graceMs: REPLY_REMINDER_GRACE_MS, reason: "turn-ended" });
+            }
+            const minutes = this.fleetConfig?.defaults?.reply_overdue_minutes ?? DEFAULT_REPLY_OVERDUE_MINUTES;
+            outbox.notifyOverdueReplyObligations({ now, overdueMs: minutes * 60_000, ownerIdle: name => stateOf(name) !== "working" });
+        }
+        catch (err) {
+            this.logger.error({ err }, "Reply-obligation sweep failed");
+        }
+    }
     scheduleDeliveryOutboxPump(delayMs = 0) {
         if (!this.deliveryOutbox || this.shuttingDown)
             return;
@@ -4688,7 +4713,7 @@ export class FleetManager {
             this.logger.debug({ emoji: r.emoji, chatId: r.chatId }, "Reaction in an unrouted channel — ignoring");
             return;
         }
-        if (DELIVERY_STATUS_EMOJIS.has(r.emoji)) {
+        if (this.isOwnStatusReaction(r)) {
             this.logger.debug({ emoji: r.emoji, user: r.username }, "Ignoring delivery-status emoji as a reaction");
             return;
         }
@@ -5229,7 +5254,7 @@ export class FleetManager {
                 // path, so a later delivery status replaces (not stacks onto) this
                 // acknowledgement.
                 if (msg.chatId && msg.messageId) {
-                    this.reactMessageStatus(generalInstance, msg.chatId, msg.messageId, "👀", msg.threadId || undefined);
+                    this.reactMessageStatus(generalInstance, msg.chatId, msg.messageId, "received", msg.threadId || undefined);
                 }
                 this.warnIfRateLimited(generalInstance, msg);
                 const { text, extraMeta } = await processAttachments(msg, inboundAdapter, this.logger, generalInstance);
@@ -5321,7 +5346,7 @@ export class FleetManager {
         // status path, so a later delivery status replaces (not stacks onto) this
         // acknowledgement. Same bound-adapter routing as the status path itself.
         if (msg.chatId && msg.messageId) {
-            this.reactMessageStatus(instanceName, msg.chatId, msg.messageId, "👀", msg.threadId || undefined);
+            this.reactMessageStatus(instanceName, msg.chatId, msg.messageId, "received", msg.threadId || undefined);
         }
         // These may hit Discord API (topic icon, archive) — do after react
         if (this.topicArchiver.isArchived(threadId)) {
@@ -5363,7 +5388,7 @@ export class FleetManager {
                 // Reconciled status path (not a bare add): a retry that later
                 // succeeds replaces this ❌ with ✅ instead of leaving both. Chat and
                 // thread travel separately so Telegram addresses the supergroup.
-                this.finishDeliveryStatus(instanceName, msg.chatId, msg.messageId, "❌", msg.threadId || undefined);
+                this.finishDeliveryStatus(instanceName, msg.chatId, msg.messageId, "failed", msg.threadId || undefined);
             }
             return;
         }
@@ -6809,7 +6834,129 @@ export class FleetManager {
     deliveryStatusChains = new Map();
     /** #725: in-flight CLI env probes, keyed by backend name. Coalesces concurrent /model requests. */
     pendingCliEnvProbes = new Map();
-    reactMessageStatus(instanceName, chatId, messageId, emoji, threadId) {
+    /**
+     * The status emojis for an instance (#1005): its own `status_emojis`, then
+     * its channel's `options.status_emojis`, then the platform built-in. An
+     * unusable value warns once and falls through, never failing the reaction.
+     * `adapterId` pins the channel for paths that already know the bot (classic).
+     */
+    resolveStatusEmojisFor(instanceName, adapterId, adapter) {
+        const worldId = adapterId ?? this.getInstanceAdapterId(instanceName);
+        const channel = (worldId ? this.worlds.get(worldId)?.channelConfig : undefined) ?? this.getChannelConfig(worldId ?? undefined);
+        // The adapter that will react decides the vocabulary: a Telegram bot gets
+        // Telegram's reaction set even if the channel lookup fell back elsewhere.
+        const reacting = adapter ?? (worldId ? this.worlds.get(worldId)?.adapter : undefined) ?? this.adapter;
+        const platform = reacting instanceof TelegramAdapter ? "telegram" : channel?.type;
+        const resolved = resolveStatusEmojis({
+            platform,
+            platformConfig: channel?.options?.status_emojis,
+            instanceConfig: this.fleetConfig?.instances[instanceName]?.status_emojis,
+            onInvalid: (source, key, value, problem) => {
+                const at = source === "instance" ? `instances.${instanceName}` : `channel ${channel?.id ?? platform ?? "?"}`;
+                const once = `${at}:${key}:${String(value)}`;
+                if (this.warnedStatusEmojis.has(once))
+                    return;
+                this.warnedStatusEmojis.add(once);
+                this.logger.warn({ at, key, value, problem }, `Ignoring status_emojis.${key}: ${problem} — using the default`);
+            },
+        });
+        return { ...resolved, platform };
+    }
+    warnedStatusEmojis = new Set();
+    /**
+     * A Discord connection's server emojis for the Settings picker (#1005).
+     * Cached per connection — a server's emoji set changes rarely — and one
+     * fetch at a time; `refresh` forces a new one. Uses the running adapter, so
+     * the bot token never leaves the server.
+     */
+    async listGuildEmojis(channelId, refresh = false) {
+        const world = this.worlds.get(channelId);
+        if (!world)
+            return { ok: false, error: `connection "${channelId}" is not running` };
+        if (world.type !== "discord")
+            return { ok: false, error: "only Discord has server custom emoji" };
+        const adapter = world.adapter;
+        if (!adapter.listGuildEmojis)
+            return { ok: false, error: "this adapter cannot list server emojis" };
+        const cached = this.guildEmojiCache.get(channelId);
+        if (!refresh && cached && Date.now() - cached.fetched_at < FleetManager.GUILD_EMOJI_TTL_MS)
+            return { ok: true, ...cached };
+        let pending = this.guildEmojiFetches.get(channelId);
+        if (!pending) {
+            pending = adapter.listGuildEmojis().then(emojis => {
+                const entry = { fetched_at: Date.now(), emojis };
+                this.guildEmojiCache.set(channelId, entry);
+                return entry;
+            }).finally(() => this.guildEmojiFetches.delete(channelId));
+            this.guildEmojiFetches.set(channelId, pending);
+        }
+        try {
+            return { ok: true, ...(await pending) };
+        }
+        catch (e) {
+            return { ok: false, error: `Discord refused the emoji list: ${e.message}` };
+        }
+    }
+    static GUILD_EMOJI_TTL_MS = 10 * 60_000;
+    guildEmojiCache = new Map();
+    guildEmojiFetches = new Map();
+    /** What the instructions tell `instanceName` not to react with (its own status set). */
+    statusEmojiAvoidList(instanceName) {
+        return statusAvoidList(this.resolveStatusEmojisFor(instanceName));
+    }
+    /** The progress bubble's leading emoji, in the form the channel renders. */
+    progressPrefixFor(instanceName) {
+        const r = this.resolveStatusEmojisFor(instanceName);
+        const builtin = builtinStatusEmojis(r.platform).progress_prefix;
+        return r.progress_prefix === builtin ? undefined : textForm(r.platform, r.progress_prefix);
+    }
+    /**
+     * Is this inbound reaction one of the fleet's own delivery-status stamps?
+     * Those are machine indicators and must not reach any instance as a user
+     * reaction (#1005 point 3). When every bot's user id is known, the check
+     * keys on WHO reacted: a fleet bot's reaction is a status stamp only if it
+     * is in that bot's instances' status set (other bot reactions are agent
+     * signals and pass), and a human's reaction always passes — whatever emoji
+     * a persona picked. Without every id, fall back to the emoji alone.
+     */
+    isOwnStatusReaction(r) {
+        const key = reactionMatchKey(r.emoji, r.emojiId);
+        const worlds = [...this.worlds.values()];
+        const names = new Set([
+            ...Object.keys(this.fleetConfig?.instances ?? {}),
+            ...(this.classicChannels?.getAll?.() ?? []).map(c => c.instanceName),
+            ...this.instanceWorldBinding.keys(),
+        ]);
+        if (worlds.length > 0 && worlds.every(w => !!w.botUserId)) {
+            const reactorWorlds = new Set(worlds.filter(w => w.botUserId === r.userId).map(w => w.id));
+            if (reactorWorlds.size === 0)
+                return false; // a human, or a bot outside this fleet
+            return [...names]
+                .filter(n => reactorWorlds.has(this.getInstanceAdapterId(n) ?? ""))
+                .some(n => statusMatchKeys(this.resolveStatusEmojisFor(n)).includes(key));
+        }
+        // Fallback: the built-in ladder (as before #1005) plus every value an
+        // operator configured. Not the Telegram built-ins — 👎 is AgEnD's failed
+        // stamp there, but also far too common a human reaction to swallow blind.
+        const keys = new Set(statusMatchKeys(builtinStatusEmojis(undefined)));
+        for (const name of names) {
+            const resolved = this.resolveStatusEmojisFor(name);
+            const builtin = builtinStatusEmojis(resolved.platform);
+            for (const k of STATUS_EMOJI_KEYS)
+                if (resolved[k] !== builtin[k])
+                    keys.add(statusMatchKey(resolved[k]));
+        }
+        return keys.has(key);
+    }
+    /**
+     * The "received" reaction for paths that react with the inbound message's
+     * own adapter rather than through reactMessageStatus (classic bots).
+     */
+    receivedReactionFor(instanceName, adapter, adapterId) {
+        const resolved = this.resolveStatusEmojisFor(instanceName, adapterId, adapter);
+        return reactionForm(resolved.platform, resolved.received);
+    }
+    reactMessageStatus(instanceName, chatId, messageId, status, threadId) {
         // React via the adapter BOUND to this instance — NOT the first discord world.
         // Otherwise, in a same-channel/same-guild multi-bot setup, the inbound 👀
         // (bound bot) and the delivery/confirm reactions (some other bot) come from
@@ -6817,40 +6964,41 @@ export class FleetManager {
         const adapter = this.getAdapterForInstance(instanceName) ?? this.adapter;
         if (!adapter)
             return;
-        const statusEmoji = adapter instanceof TelegramAdapter
-            ? TELEGRAM_DELIVERY_STATUS_REACTIONS.get(emoji)
-            : emoji;
-        // Telegram has a deliberately smaller status vocabulary, and every mapped
-        // value is accepted by ReactionTypeEmoji. Unknown statuses stay a no-op.
-        if (!statusEmoji)
+        const resolved = this.resolveStatusEmojisFor(instanceName, undefined, adapter);
+        const configured = resolved[status];
+        // Unknown statuses stay a no-op. Every resolved Telegram value has been
+        // checked against the ReactionTypeEmoji set (status-emojis.ts).
+        if (!configured)
             return;
+        const statusEmoji = reactionForm(resolved.platform, configured);
         // Bot-scoped: sibling bots reacting on the same message must not clear
         // each other's state — every removal below targets this adapter's own
         // reactions (@me on Discord, the bot's list on Telegram).
         const adapterId = typeof adapter.id === "string"
             ? adapter.id : "?";
         const key = `${adapterId}:${chatId}:${threadId ?? ""}:${messageId}`;
-        this.queueDeliveryStatusReaction(adapter, key, chatId, messageId, statusEmoji, threadId);
+        this.queueDeliveryStatusReaction(adapter, key, chatId, messageId, statusEmoji, threadId, status);
     }
     /**
-     * Apply a terminal delivery verdict. Telegram maps ✅ to 👀 and ❌ to 👎 in
-     * reactMessageStatus; Discord continues to show the verdict emoji directly.
+     * Apply a terminal delivery verdict. On Telegram the built-in delivered is
+     * 👀 and failed is 👎; Discord shows ✅/❌ — both configurable (#1005).
      */
-    finishDeliveryStatus(instanceName, chatId, messageId, emoji, threadId) {
-        this.reactMessageStatus(instanceName, chatId, messageId, emoji, threadId);
+    finishDeliveryStatus(instanceName, chatId, messageId, status, threadId) {
+        this.reactMessageStatus(instanceName, chatId, messageId, status, threadId);
     }
-    queueDeliveryStatusReaction(adapter, key, chatId, messageId, emoji, threadId) {
+    queueDeliveryStatusReaction(adapter, key, chatId, messageId, emoji, threadId, status) {
         const prev = this.deliveryStatusChains.get(key) ?? Promise.resolve();
-        const run = prev.then(() => this.applyDeliveryStatusReaction(adapter, key, chatId, messageId, emoji, threadId));
+        const run = prev.then(() => this.applyDeliveryStatusReaction(adapter, key, chatId, messageId, emoji, threadId, status));
         this.deliveryStatusChains.set(key, run);
         void run.then(() => { if (this.deliveryStatusChains.get(key) === run)
             this.deliveryStatusChains.delete(key); }, () => { if (this.deliveryStatusChains.get(key) === run)
             this.deliveryStatusChains.delete(key); });
     }
-    async applyDeliveryStatusReaction(adapter, key, chatId, messageId, emoji, threadId) {
+    async applyDeliveryStatusReaction(adapter, key, chatId, messageId, emoji, threadId, status) {
         try {
             const target = adapter instanceof TelegramAdapter ? chatId : (threadId ?? chatId);
-            const prev = this.lastStatusEmoji.get(key);
+            const last = this.lastStatusEmoji.get(key);
+            const prev = last?.emoji;
             if (emoji == null) {
                 if (prev && adapter.unreact) {
                     await adapter.unreact(target, messageId, prev, threadId);
@@ -6865,15 +7013,16 @@ export class FleetManager {
                 return;
             // Thread-aware adapters (Discord) react where the thread is; Telegram
             // addresses the supergroup chat and ignores the thread part.
-            // #972: add-only by default — only remove ❌ when leaving the failed
-            // state. 👀/⏳/✅ stacking together is harmless; leaving ❌ visible
-            // after a recovery would be misleading.
-            if (prev === "❌" && adapter.unreact && !(adapter instanceof TelegramAdapter)) {
+            // #972: add-only by default — only remove the failed emoji when leaving
+            // the failed state. 👀/⏳/✅ stacking together is harmless; leaving ❌
+            // visible after a recovery would be misleading. `prev` is the exact
+            // form it was added with, so a custom emoji comes off too (#1005).
+            if (last?.status === "failed" && adapter.unreact && !(adapter instanceof TelegramAdapter)) {
                 // Best effort: a failed removal must not block the new status.
-                await adapter.unreact(target, messageId, prev, threadId).catch(e => this.logger.debug({ err: e.message }, "Delivery status reaction removal failed"));
+                await adapter.unreact(target, messageId, last.emoji, threadId).catch(e => this.logger.debug({ err: e.message }, "Delivery status reaction removal failed"));
             }
             await adapter.react(target, messageId, emoji, threadId);
-            this.lastStatusEmoji.set(key, emoji);
+            this.lastStatusEmoji.set(key, { emoji, status });
         }
         catch (e) {
             this.logger.debug({ err: e.message }, "Message status react failed");
@@ -8080,11 +8229,12 @@ export class FleetManager {
             return;
         }
         const publication = this.beginCancelButtonPublication(instanceName, correlationId);
+        const initialProgressText = FleetManager.progressText(0, null, 1, this.progressPrefixFor(instanceName));
         try {
             const sent = await adapter.notifyAlert(chatId, {
                 type: "cancel",
                 instanceName,
-                message: "👀 處理中…",
+                message: initialProgressText,
                 choices: [{ id: `cancel:${instanceName}`, label: t("cancel.button") }],
             }, threadId ? { threadId } : undefined);
             publication.inFlight = false;
@@ -8103,7 +8253,7 @@ export class FleetManager {
                 // Matches the text notifyAlert just posted, so the first 60s tick does
                 // not re-edit identical text — which put a "(edited)" mark on Discord
                 // with nothing visibly changed.
-                lastProgressText: "👀 處理中…",
+                lastProgressText: initialProgressText,
                 // A reply can re-post the same in-flight bubble below the reply. Carry
                 // its current list into that replacement; fresh inbound work must start
                 // empty even if the daemon's reset broadcast is still in flight.
@@ -8190,14 +8340,16 @@ export class FleetManager {
      * progress indicator (#409) — the channel showed nothing at all during long work,
      * and once the agent had replied once there was no sign it was still going.
      */
-    static progressText(elapsedMs, activity, minElapsedMs = PROGRESS_MIN_ELAPSED_MS) {
+    static progressText(elapsedMs, activity, minElapsedMs = PROGRESS_MIN_ELAPSED_MS, prefix) {
+        // A configured progress_prefix (#1005) leads both phases; the built-in
+        // switches 👀 → ⏳ once the elapsed time shows.
         if (elapsedMs < minElapsedMs)
-            return "👀 處理中…";
+            return `${prefix ?? "👀"} 處理中…`;
         const elapsed = FleetManager.formatProgressElapsed(elapsedMs);
         const detail = FleetManager.sanitizeActivity(activity);
         return detail
-            ? `⏳ 處理中… (已進行 ${elapsed} · ${detail})`
-            : `⏳ 處理中… (已進行 ${elapsed})`;
+            ? `${prefix ?? "⏳"} 處理中… (已進行 ${elapsed} · ${detail})`
+            : `${prefix ?? "⏳"} 處理中… (已進行 ${elapsed})`;
     }
     /** Render elapsed time consistently in live and retained progress bubbles. */
     static formatProgressElapsed(elapsedMs) {
@@ -8293,13 +8445,13 @@ export class FleetManager {
      * wiped by the next elapsed tick (#528 trap 2).
      */
     composeBubbleText(entry) {
-        return FleetManager.bubbleText(Date.now() - (entry.startedAt ?? Date.now()), this.instanceActivity.get(entry.instanceName), this.progressMinElapsedMs(), entry.toolProgress);
+        return FleetManager.bubbleText(Date.now() - (entry.startedAt ?? Date.now()), this.instanceActivity.get(entry.instanceName), this.progressMinElapsedMs(), entry.toolProgress, this.progressPrefixFor(entry.instanceName));
     }
     /** Pure composition of header + tool list, exposed for tests. */
-    static bubbleText(elapsedMs, activity, minElapsedMs, progress) {
+    static bubbleText(elapsedMs, activity, minElapsedMs, progress, prefix) {
         const header = FleetManager.progressText(elapsedMs, 
         // The single-line activity detail is redundant once a tool list exists.
-        progress ? undefined : activity, minElapsedMs);
+        progress ? undefined : activity, minElapsedMs, prefix);
         return progress ? `${header}\n${progress}` : header;
     }
     /** Recompose and edit the bubble in place; skips when nothing changed. */
@@ -9919,7 +10071,7 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
             const classicAdapter = this.worlds.get(msg.adapterId ?? "")?.adapter ?? this.adapter;
             const collabReactChatId = msg.threadId ?? msg.chatId;
             if (classicAdapter && collabReactChatId && msg.messageId) {
-                classicAdapter.react(collabReactChatId, msg.messageId, "👀")
+                classicAdapter.react(collabReactChatId, msg.messageId, this.receivedReactionFor(instanceName, classicAdapter, msg.adapterId))
                     .catch(e => this.logger.debug({ err: e.message }, "Auto-react failed"));
             }
             // Block /raw bypass — check the mention-stripped text so the self-marker
@@ -10024,7 +10176,7 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
         }
         if (msg.chatId && msg.messageId) {
             const reactChatId = msg.threadId ?? msg.chatId;
-            classicMsgAdapter.react(reactChatId, msg.messageId, "👀")
+            classicMsgAdapter.react(reactChatId, msg.messageId, this.receivedReactionFor(instanceName, classicMsgAdapter, msg.adapterId))
                 .catch(e => this.logger.debug({ err: e.message }, "Auto-react failed"));
             if (saved) {
                 const savedEmoji = msg.source === "telegram"
@@ -11412,6 +11564,10 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
             clearInterval(this.eventLogPruneTimer);
             this.eventLogPruneTimer = null;
         }
+        if (this.replyObligationTimer) {
+            clearInterval(this.replyObligationTimer);
+            this.replyObligationTimer = null;
+        }
         if (this.logRotateTimer) {
             clearInterval(this.logRotateTimer);
             this.logRotateTimer = null;