@songsid/agend 2.1.6 → 2.1.7-beta.1

package/dist/fleet-manager.d.ts

@@ -1015,7 +1015,29 @@ export declare class FleetManager implements FleetContext, LifecycleContext, Arc
     removeInstance(name: string, authorization: ExplicitInstanceRemoval): Promise<void>;
     startStatuslineWatcher(name: string): void;
     stopStatuslineWatcher(name: string): void;
-    reactMessageStatus(instanceName: string, chatId: string, messageId: string, emoji: string): void;
+    /**
+     * Last delivery status applied per bot+message. Unbounded by design: any cap
+     * reintroduces the hole where a forgotten ❌ can never be cleared, and an
+     * entry is two short strings (id pair plus one emoji) — thousands of
+     * status-reacted messages cost kilobytes. A bot restart loses it, degrading
+     * to a plain add (never worse than the old behaviour).
+     */
+    private lastStatusEmoji;
+    /**
+     * One in-flight status update per bot+message: updates run strictly in call
+     * order, so a delayed ❌ add can never land after a newer ✅'s removal —
+     * the final state is always the latest call. Entries delete themselves when
+     * the chain drains, so idle messages hold no memory.
+     */
+    private deliveryStatusChains;
+    reactMessageStatus(instanceName: string, chatId: string, messageId: string, emoji: string, threadId?: string): void;
+    /**
+     * Apply a terminal delivery verdict. Telegram maps ✅ to 👀 and ❌ to 👎 in
+     * reactMessageStatus; Discord continues to show the verdict emoji directly.
+     */
+    finishDeliveryStatus(instanceName: string, chatId: string, messageId: string, emoji: string, threadId?: string): void;
+    private queueDeliveryStatusReaction;
+    private applyDeliveryStatusReaction;
     private static FAILOVER_TRIGGER_PCT;
     private static FAILOVER_RECOVER_PCT;
     checkModelFailover(name: string, fiveHourPct: number): void;
@@ -1356,13 +1378,6 @@ export declare class FleetManager implements FleetContext, LifecycleContext, Arc
      * Used by report_result, where the sender's self-derived name may not match
      * the target-address name the button was registered under. */
     clearCancelButtonByCorrelation(correlationId: string): void;
-    /**
-     * Reaction target chat id. Telegram reactions key on the supergroup chat_id
-     * (the topic thread is NOT a chat_id), so a forum-topic message must react on
-     * msg.chatId — reacting on threadId silently fails. Discord reactions key on
-     * the channel/thread id.
-     */
-    private reactTarget;
     /** Remember the user message just delivered, so we can react ✅ when done. */
     private trackInboundMsg;
     /** Clear the tracked last-inbound message after the agent replies. The ✅

package/dist/fleet-manager.js

@@ -16,6 +16,17 @@ 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 { 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";
@@ -25,6 +36,7 @@ import { TmuxManager } from "./tmux-manager.js";
 import { AccessManager } from "./channel/access-manager.js";
 import { IpcClient } from "./channel/ipc-bridge.js";
 import { createAdapter } from "./channel/factory.js";
+import { TelegramAdapter } from "./channel/adapters/telegram.js";
 import { createBackend } from "./backend/factory.js";
 import { isModelCompatible } from "./backend/types.js";
 import { createLogger, rotateLogIfNeeded } from "./logger.js";
@@ -4950,13 +4962,11 @@ export class FleetManager {
                 if (msg.adapterId)
                     this.bindInstanceAdapter(generalInstance, msg.adapterId, true);
                 const inboundAdapter = this.worlds.get(msg.adapterId ?? "")?.adapter ?? this.adapter;
-                // React immediately — before any other API calls. Use the adapter BOUND to
-                // the instance (not whichever same-guild bot received the event first) so
-                // exactly the owning bot reacts — no duplicate 👀 from a sibling bot.
+                // React immediately — before any other API calls — through the status
+                // path, so a later delivery status replaces (not stacks onto) this
+                // acknowledgement.
                 if (msg.chatId && msg.messageId) {
-                    const reactAdapter = this.getAdapterForInstance(generalInstance) ?? inboundAdapter;
-                    reactAdapter.react(msg.threadId ?? msg.chatId, msg.messageId, "👀")
-                        .catch(e => this.logger.debug({ err: e.message }, "Auto-react failed"));
+                    this.reactMessageStatus(generalInstance, msg.chatId, msg.messageId, "👀", msg.threadId || undefined);
                 }
                 this.warnIfRateLimited(generalInstance, msg);
                 const { text, extraMeta } = await processAttachments(msg, inboundAdapter, this.logger, generalInstance);
@@ -5044,13 +5054,11 @@ export class FleetManager {
         if (msg.adapterId)
             this.bindInstanceAdapter(instanceName, msg.adapterId, true);
         const inboundAdapter = this.worlds.get(msg.adapterId ?? "")?.adapter ?? this.adapter;
-        // React immediately — before any other Discord API calls. Use the adapter
-        // BOUND to the instance (not whichever same-guild bot received the event
-        // first) so exactly the owning bot reacts — no duplicate 👀 from a sibling.
+        // React immediately — before any other Discord API calls — through the
+        // 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) {
-            const reactAdapter = this.getAdapterForInstance(instanceName) ?? inboundAdapter;
-            reactAdapter.react(this.reactTarget(msg), msg.messageId, "👀")
-                .catch(e => this.logger.debug({ err: e.message }, "Auto-react failed"));
+            this.reactMessageStatus(instanceName, msg.chatId, msg.messageId, "👀", msg.threadId || undefined);
         }
         // These may hit Discord API (topic icon, archive) — do after react
         if (this.topicArchiver.isArchived(threadId)) {
@@ -5089,8 +5097,10 @@ export class FleetManager {
         catch (err) {
             this.logger.warn({ err: err.message, instanceName }, "Wake/delivery failed");
             if (msg.chatId && msg.messageId) {
-                const reactAdapter = this.getAdapterForInstance(instanceName) ?? inboundAdapter;
-                reactAdapter.react(this.reactTarget(msg), msg.messageId, "❌").catch(() => { });
+                // 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);
             }
             return;
         }
@@ -6503,17 +6513,89 @@ export class FleetManager {
         // Pausing stops I/O but retains the last observed limits for status views.
         this.statuslineWatcher.unwatch(name, true);
     }
-    reactMessageStatus(instanceName, chatId, messageId, emoji) {
+    /**
+     * Last delivery status applied per bot+message. Unbounded by design: any cap
+     * reintroduces the hole where a forgotten ❌ can never be cleared, and an
+     * entry is two short strings (id pair plus one emoji) — thousands of
+     * status-reacted messages cost kilobytes. A bot restart loses it, degrading
+     * to a plain add (never worse than the old behaviour).
+     */
+    lastStatusEmoji = new Map();
+    /**
+     * One in-flight status update per bot+message: updates run strictly in call
+     * order, so a delayed ❌ add can never land after a newer ✅'s removal —
+     * the final state is always the latest call. Entries delete themselves when
+     * the chain drains, so idle messages hold no memory.
+     */
+    deliveryStatusChains = new Map();
+    reactMessageStatus(instanceName, chatId, messageId, emoji, 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
         // different bots, leaving a duplicate 👀 that never turns into ✅.
         const adapter = this.getAdapterForInstance(instanceName) ?? this.adapter;
-        // Status reactions are Discord-only (TG/others use the inbound react path).
-        if (!adapter || adapter.type !== "discord")
+        if (!adapter)
             return;
-        adapter.react(chatId, messageId, emoji)
-            .catch(e => this.logger.debug({ err: e.message }, "Message status react failed"));
+        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)
+            return;
+        // 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);
+    }
+    /**
+     * Apply a terminal delivery verdict. Telegram maps ✅ to 👀 and ❌ to 👎 in
+     * reactMessageStatus; Discord continues to show the verdict emoji directly.
+     */
+    finishDeliveryStatus(instanceName, chatId, messageId, emoji, threadId) {
+        this.reactMessageStatus(instanceName, chatId, messageId, emoji, threadId);
+    }
+    queueDeliveryStatusReaction(adapter, key, chatId, messageId, emoji, threadId) {
+        const prev = this.deliveryStatusChains.get(key) ?? Promise.resolve();
+        const run = prev.then(() => this.applyDeliveryStatusReaction(adapter, key, chatId, messageId, emoji, threadId));
+        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) {
+        try {
+            const target = adapter instanceof TelegramAdapter ? chatId : (threadId ?? chatId);
+            const prev = this.lastStatusEmoji.get(key);
+            if (emoji == null) {
+                if (prev && adapter.unreact) {
+                    await adapter.unreact(target, messageId, prev, threadId);
+                    this.lastStatusEmoji.delete(key);
+                }
+                return;
+            }
+            // A Telegram status may map multiple lifecycle states to the same
+            // reaction. Avoid resending it: an agent may have replaced the one
+            // reaction slot with its own 👍 between delivered and confirmed.
+            if (prev === emoji)
+                return;
+            // Thread-aware adapters (Discord) react where the thread is; Telegram
+            // addresses the supergroup chat and ignores the thread part.
+            // Discord needs the old reaction removed before the new one is added.
+            // Telegram's setMessageReaction replaces the bot's one current reaction.
+            if (prev && prev !== emoji && 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.react(target, messageId, emoji, threadId);
+            this.lastStatusEmoji.set(key, emoji);
+        }
+        catch (e) {
+            this.logger.debug({ err: e.message }, "Message status react failed");
+        }
     }
     // ── Model failover ──────────────────────────────────────────────────────
     static FAILOVER_TRIGGER_PCT = 90;
@@ -8186,15 +8268,6 @@ export class FleetManager {
                 this.retireButton(e);
         }
     }
-    /**
-     * Reaction target chat id. Telegram reactions key on the supergroup chat_id
-     * (the topic thread is NOT a chat_id), so a forum-topic message must react on
-     * msg.chatId — reacting on threadId silently fails. Discord reactions key on
-     * the channel/thread id.
-     */
-    reactTarget(msg) {
-        return msg.source === "telegram" ? msg.chatId : (msg.threadId ?? msg.chatId);
-    }
     /** Remember the user message just delivered, so we can react ✅ when done. */
     trackInboundMsg(instanceName, msg) {
         if (!msg.chatId || !msg.messageId)