@songsid/agend 2.1.4-beta.8 → 2.1.4-beta.9

package/dist/fleet-manager.d.ts

@@ -106,6 +106,8 @@ export declare class FleetManager implements FleetContext, LifecycleContext, Arc
     readonly replyDeduper: ReplyDeduper;
     /** instanceName → what it is doing right now, when the backend can tell us. */
     private instanceActivity;
+    /** instanceName → this turn's tool list (multi-line), for the bubble. */
+    private instanceProgress;
     /** instanceName → tail of deliveries waiting for its IPC to come back. */
     private ipcWaitTails;
     /** instanceName → restart currently executing; concurrent callers join it. */
@@ -644,6 +646,26 @@ export declare class FleetManager implements FleetContext, LifecycleContext, Arc
      * never used to decide anything — purely what the user is shown.
      */
     private cacheInstanceActivity;
+    /**
+     * Cache the turn's tool-progress list and push it into the instance's live
+     * bubble, coalesced so a burst of tool events cannot flood the Bot API
+     * (Telegram's flood limit is per-chat across ALL forum topics, so edits are
+     * rate-limited per bubble AND ride behind the daemon-side 3s coalescer).
+     */
+    private cacheInstanceProgress;
+    /** At most one progress-driven edit per bubble per TOOL_PROGRESS_EDIT_MIN_MS. */
+    private scheduleProgressEdit;
+    /**
+     * The ONE composer for the bubble text. Both writers — the elapsed-time
+     * ticker and the tool-progress push — go through here; two independent
+     * renderers editing the same message is how the progress list used to get
+     * wiped by the next elapsed tick (#528 trap 2).
+     */
+    private composeBubbleText;
+    /** Pure composition of header + tool list, exposed for tests. */
+    static bubbleText(elapsedMs: number, activity: string | undefined, minElapsedMs: number, progress: string | undefined): string;
+    /** Recompose and edit the bubble in place; skips when nothing changed. */
+    private refreshBubble;
     /**
      * Refresh the button's text in place while the instance keeps working.
      *

package/dist/fleet-manager.js

@@ -135,6 +135,8 @@ const CANCEL_BTN_LEDGER_FILE = "cancel-buttons.json";
  * exactly one progress message per turn, and it is the cancel button itself.
  */
 const PROGRESS_UPDATE_INTERVAL_MS = 60_000;
+/** Floor between tool-progress-driven bubble edits (Telegram flood safety). */
+const TOOL_PROGRESS_EDIT_MIN_MS = 4_000;
 /** Elapsed time is only shown once work has clearly outlasted a quick answer. */
 /**
  * Default delay before the button starts showing elapsed time. Configurable via
@@ -253,6 +255,8 @@ export class FleetManager {
     replyDeduper = new ReplyDeduper();
     /** instanceName → what it is doing right now, when the backend can tell us. */
     instanceActivity = new Map();
+    /** instanceName → this turn's tool list (multi-line), for the bubble. */
+    instanceProgress = new Map();
     /** instanceName → tail of deliveries waiting for its IPC to come back. */
     ipcWaitTails = new Map();
     /** instanceName → restart currently executing; concurrent callers join it. */
@@ -2235,6 +2239,26 @@ export class FleetManager {
                 const result = await this.topicCommands.sendCompact(name);
                 await data.respond(result);
             }
+            else if (data.command === "steer") {
+                const name = this.resolveSlashTarget(data.channelId, adapterId);
+                if (!name) {
+                    await data.respond(t("classic.no_agent"));
+                    return;
+                }
+                const steerText = String(data.options?.message ?? "").trim();
+                if (!steerText) {
+                    await data.respond(t("steer.usage"));
+                    return;
+                }
+                // chat_id/message_id stay empty: a slash interaction has no channel
+                // message to react to, and an empty chat_id keeps updateLastChat from
+                // rerouting the instance's replies to the slash context.
+                const result = this.topicCommands.sendSteer(name, steerText, {
+                    chatId: "", messageId: "", username: data.username ?? "user",
+                    userId: data.userId ?? "", threadId: undefined, adapterId, source: "discord",
+                });
+                await data.respond(result);
+            }
             else if (data.command === "clear") {
                 await this.handleClearSlash(data, adapterId);
             }
@@ -2359,6 +2383,26 @@ export class FleetManager {
                 const result = await this.topicCommands.sendCompact(name);
                 await data.respond(result);
             }
+            else if (data.command === "steer") {
+                const name = this.resolveSlashTarget(data.channelId, adapterId);
+                if (!name) {
+                    await data.respond(t("classic.no_agent"));
+                    return;
+                }
+                const steerText = String(data.options?.message ?? "").trim();
+                if (!steerText) {
+                    await data.respond(t("steer.usage"));
+                    return;
+                }
+                // chat_id/message_id stay empty: a slash interaction has no channel
+                // message to react to, and an empty chat_id keeps updateLastChat from
+                // rerouting the instance's replies to the slash context.
+                const result = this.topicCommands.sendSteer(name, steerText, {
+                    chatId: "", messageId: "", username: data.username ?? "user",
+                    userId: data.userId ?? "", threadId: undefined, adapterId, source: "discord",
+                });
+                await data.respond(result);
+            }
         }, this.logger, "adapter.slash_command"));
         await this.topicCommands.registerBotCommands().catch(e => this.logger.warn({ err: e }, "registerBotCommands failed (non-fatal)"));
         // Background-probe each backend's CLI env (version/models) → cli-env cache.
@@ -2641,6 +2685,26 @@ export class FleetManager {
                 const result = await this.topicCommands.sendCompact(name);
                 await data.respond(result);
             }
+            else if (data.command === "steer") {
+                const name = this.resolveSlashTarget(data.channelId, adapterId);
+                if (!name) {
+                    await data.respond(t("classic.no_agent"));
+                    return;
+                }
+                const steerText = String(data.options?.message ?? "").trim();
+                if (!steerText) {
+                    await data.respond(t("steer.usage"));
+                    return;
+                }
+                // chat_id/message_id stay empty: a slash interaction has no channel
+                // message to react to, and an empty chat_id keeps updateLastChat from
+                // rerouting the instance's replies to the slash context.
+                const result = this.topicCommands.sendSteer(name, steerText, {
+                    chatId: "", messageId: "", username: data.username ?? "user",
+                    userId: data.userId ?? "", threadId: undefined, adapterId, source: "discord",
+                });
+                await data.respond(result);
+            }
         }, this.logger, `adapter[${adapterId}].slash_command`));
         await adapter.start();
         if (channelConfig.group_id) {
@@ -2758,6 +2822,9 @@ export class FleetManager {
                 else if (msg.type === "instance_activity") {
                     this.cacheInstanceActivity(name, msg.activity);
                 }
+                else if (msg.type === "instance_progress") {
+                    this.cacheInstanceProgress(name, msg.progress || null);
+                }
                 else if (msg.type === "instance_state" || msg.type === "instance_state_response") {
                     this.cacheInstanceExecutionState(name, msg);
                     if (msg.type === "instance_state_response") {
@@ -3205,6 +3272,24 @@ export class FleetManager {
                     await msgAdapter?.sendText(chatId, result);
                     return;
                 }
+                // /steer — interject into the running turn. Not admin-gated: anyone who
+                // can talk to this agent can send it a message; steer only changes when
+                // it lands, and it keeps the full [user:] formatting (unlike /raw).
+                if (text === "/steer" || text.startsWith("/steer ") || text.startsWith("/steer@")) {
+                    const steerName = this.classicChannels.getInstanceByChannel(chatId, msg.adapterId);
+                    if (!steerName) {
+                        await msgAdapter?.sendText(chatId, t("classic.no_agent_start"));
+                        return;
+                    }
+                    const steerContent = text.replace(/^\/steer(@\S+)?/, "").trim();
+                    if (!steerContent) {
+                        await msgAdapter?.sendText(chatId, t("steer.usage"));
+                        return;
+                    }
+                    const result = this.topicCommands.sendSteer(steerName, steerContent, msg);
+                    await msgAdapter?.sendText(chatId, result);
+                    return;
+                }
                 // Handle /clear command (admin only) — unlike /compact this starts a
                 // fresh conversation and intentionally discards the current history.
                 if (text === "/clear" || text.startsWith("/clear@")) {
@@ -5130,6 +5215,80 @@ export class FleetManager {
         else
             this.instanceActivity.delete(name);
     }
+    /**
+     * Cache the turn's tool-progress list and push it into the instance's live
+     * bubble, coalesced so a burst of tool events cannot flood the Bot API
+     * (Telegram's flood limit is per-chat across ALL forum topics, so edits are
+     * rate-limited per bubble AND ride behind the daemon-side 3s coalescer).
+     */
+    cacheInstanceProgress(name, progress) {
+        if (progress)
+            this.instanceProgress.set(name, progress);
+        else
+            this.instanceProgress.delete(name);
+        for (const entry of this.cancelButtons.values()) {
+            if (entry.instanceName === name)
+                this.scheduleProgressEdit(entry);
+        }
+    }
+    /** At most one progress-driven edit per bubble per TOOL_PROGRESS_EDIT_MIN_MS. */
+    scheduleProgressEdit(entry) {
+        const since = Date.now() - (entry.lastProgressEditAt ?? 0);
+        if (since >= TOOL_PROGRESS_EDIT_MIN_MS) {
+            this.refreshBubble(entry);
+            return;
+        }
+        if (entry.progressEditTimer)
+            return; // trailing edit already scheduled
+        entry.progressEditTimer = setTimeout(() => {
+            entry.progressEditTimer = undefined;
+            this.refreshBubble(entry);
+        }, TOOL_PROGRESS_EDIT_MIN_MS - since);
+        entry.progressEditTimer.unref?.();
+    }
+    /**
+     * The ONE composer for the bubble text. Both writers — the elapsed-time
+     * ticker and the tool-progress push — go through here; two independent
+     * renderers editing the same message is how the progress list used to get
+     * 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(), this.instanceProgress.get(entry.instanceName));
+    }
+    /** Pure composition of header + tool list, exposed for tests. */
+    static bubbleText(elapsedMs, activity, minElapsedMs, progress) {
+        const header = FleetManager.progressText(elapsedMs, 
+        // The single-line activity detail is redundant once a tool list exists.
+        progress ? undefined : activity, minElapsedMs);
+        return progress ? `${header}\n${progress}` : header;
+    }
+    /** Recompose and edit the bubble in place; skips when nothing changed. */
+    refreshBubble(entry) {
+        if (!this.cancelButtons.has(entry.messageId)) {
+            clearInterval(entry.progressTimer);
+            return;
+        }
+        const text = this.composeBubbleText(entry);
+        if (text === entry.lastProgressText)
+            return; // nothing changed — skip the API call
+        const adapter = this.getAdapterForInstance(entry.instanceName) ?? this.adapter;
+        if (!adapter?.editAlert)
+            return;
+        entry.lastProgressText = text;
+        entry.lastProgressEditAt = Date.now();
+        adapter.editAlert(entry.chatId, entry.messageId, {
+            type: "cancel",
+            instanceName: entry.instanceName,
+            message: text,
+            choices: [{ id: `cancel:${entry.instanceName}`, label: t("cancel.button") }],
+        }, entry.threadId ? { threadId: entry.threadId } : undefined)
+            .catch(err => {
+            // A failed progress edit must never escalate: the button still works and
+            // the next tick retries. Common causes are a deleted message or a
+            // rate limit.
+            this.logger.debug({ err, instanceName: entry.instanceName }, "Progress edit failed");
+        });
+    }
     /**
      * Refresh the button's text in place while the instance keeps working.
      *
@@ -5147,31 +5306,7 @@ export class FleetManager {
         return PROGRESS_MIN_ELAPSED_MS;
     }
     startProgressTicker(entry) {
-        const tick = () => {
-            if (!this.cancelButtons.has(entry.messageId)) {
-                clearInterval(entry.progressTimer);
-                return;
-            }
-            const text = FleetManager.progressText(Date.now() - (entry.startedAt ?? Date.now()), this.instanceActivity.get(entry.instanceName), this.progressMinElapsedMs());
-            if (text === entry.lastProgressText)
-                return; // nothing changed — skip the API call
-            const adapter = this.getAdapterForInstance(entry.instanceName) ?? this.adapter;
-            if (!adapter?.editAlert)
-                return;
-            entry.lastProgressText = text;
-            adapter.editAlert(entry.chatId, entry.messageId, {
-                type: "cancel",
-                instanceName: entry.instanceName,
-                message: text,
-                choices: [{ id: `cancel:${entry.instanceName}`, label: t("cancel.button") }],
-            }, entry.threadId ? { threadId: entry.threadId } : undefined)
-                .catch(err => {
-                // A failed progress edit must never escalate: the button still works and
-                // the next tick retries. Common causes are a deleted message or a
-                // rate limit.
-                this.logger.debug({ err, instanceName: entry.instanceName }, "Progress edit failed");
-            });
-        };
+        const tick = () => this.refreshBubble(entry);
         entry.progressTimer = setInterval(tick, PROGRESS_UPDATE_INTERVAL_MS);
         entry.progressTimer.unref?.();
         // One extra tick right when the threshold passes, so a 30s threshold shows
@@ -5239,6 +5374,8 @@ export class FleetManager {
             clearInterval(entry.idleCheckTimer);
         if (entry.progressTimer)
             clearInterval(entry.progressTimer);
+        if (entry.progressEditTimer)
+            clearTimeout(entry.progressEditTimer);
         if (entry.replyGraceTimer)
             clearTimeout(entry.replyGraceTimer);
         this.cancelButtons.delete(entry.messageId);