@songsid/agend 2.1.2-beta.24 → 2.1.2-beta.25

package/dist/fleet-manager.js

@@ -122,19 +122,24 @@ const CANCEL_BTN_LEDGER_FILE = "cancel-buttons.json";
  */
 const PROGRESS_UPDATE_INTERVAL_MS = 60_000;
 /** Elapsed time is only shown once work has clearly outlasted a quick answer. */
-const PROGRESS_MIN_ELAPSED_MS = 2 * 60_000;
+/**
+ * Default delay before the button starts showing elapsed time. Configurable via
+ * `defaults.progress_min_elapsed` (seconds) in fleet.yaml. 30s is the balance
+ * point: most quick answers finish inside it (no churn for ordinary turns),
+ * while anything real shows signs of life well before the old two minutes.
+ */
+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 machine signals: the delivery-status
- * ladder (⏳ queued, 👀 delivered, ✅ confirmed, ❌ failed) and the 🫡 ack. They
- * are indicators, not opinions, so they never belong in the reactions queue —
- * regardless of who they arrive from, because the adapter-level bot filter can
- * miss (Discord partial users may not carry the `bot` flag). The cost is that a
- * human genuinely reacting ✅ is also dropped; with four bot-stamped meanings
- * already attached to these glyphs, that reading is ambiguous anyway.
+ * 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(["👀", "⏳", "✅", "❌", "🫡"]);
+const DELIVERY_STATUS_EMOJIS = new Set(["👀", "⏳", "✅", "❌"]);
 /**
  * How long a delivery waits out a disconnected instance IPC before giving up.
  *
@@ -4226,8 +4231,8 @@ 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) {
-        if (elapsedMs < PROGRESS_MIN_ELAPSED_MS)
+    static progressText(elapsedMs, activity, minElapsedMs = PROGRESS_MIN_ELAPSED_MS) {
+        if (elapsedMs < minElapsedMs)
             return "👀 處理中…";
         const totalSeconds = Math.floor(elapsedMs / 1000);
         const minutes = Math.floor(totalSeconds / 60);
@@ -4278,13 +4283,22 @@ export class FleetManager {
      * and the Bot API treats that as "clear the keyboard" — so editing with it would
      * delete the very cancel button this is trying to keep alive.
      */
+    /** Configured threshold before elapsed time appears, in ms. */
+    progressMinElapsedMs() {
+        const seconds = this.fleetConfig?.defaults
+            ?.progress_min_elapsed;
+        if (typeof seconds === "number" && Number.isFinite(seconds) && seconds >= 0) {
+            return seconds * 1000;
+        }
+        return PROGRESS_MIN_ELAPSED_MS;
+    }
     startProgressTicker(entry) {
-        entry.progressTimer = setInterval(() => {
+        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));
+            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;
@@ -4303,8 +4317,17 @@ export class FleetManager {
                 // rate limit.
                 this.logger.debug({ err, instanceName: entry.instanceName }, "Progress edit failed");
             });
-        }, PROGRESS_UPDATE_INTERVAL_MS);
+        };
+        entry.progressTimer = setInterval(tick, PROGRESS_UPDATE_INTERVAL_MS);
         entry.progressTimer.unref?.();
+        // One extra tick right when the threshold passes, so a 30s threshold shows
+        // time at ~30s instead of waiting for the first 60s interval. Costs at most
+        // one additional edit per turn that lives past the threshold.
+        const firstAt = this.progressMinElapsedMs() - (Date.now() - (entry.startedAt ?? Date.now()));
+        if (firstAt > 0 && firstAt < PROGRESS_UPDATE_INTERVAL_MS) {
+            const firstTick = setTimeout(tick, firstAt);
+            firstTick.unref?.();
+        }
     }
     /**
      * After a reply: give the instance REPLY_RETIRE_GRACE_MS to resume working; if
@@ -5572,6 +5595,20 @@ When users create specialized instances, suggest these configurations:
     /** Apply a model to an instance: runtime paste (claude-code) or persist + restart (others). */
     /** AgEnD's canonical effort ladder, low → max. Backends expose a subset. */
     static EFFORT_LEVELS = ["low", "medium", "high", "xhigh", "max"];
+    /** How this instance's backend applies an effort change. */
+    effortStrategyFor(instanceName) {
+        try {
+            const backend = createBackend(this.backendNameForInstance(instanceName), this.getInstanceDir(instanceName));
+            const strategy = backend.getEffortStrategy?.() ?? "unsupported";
+            // A backend claiming support but listing no levels is unusable either way.
+            return strategy !== "unsupported" && (backend.getEffortLevels?.() ?? []).length > 0
+                ? strategy
+                : "unsupported";
+        }
+        catch {
+            return "unsupported";
+        }
+    }
     /** Effort levels this instance's backend actually accepts (empty = unsupported). */
     effortLevelsFor(instanceName) {
         try {
@@ -5672,7 +5709,7 @@ When users create specialized instances, suggest these configurations:
             if (!this.instanceIpcClients.get(instanceName))
                 return `${warn}❌ ${instanceName} is not running.`;
             this.pasteRawToClassicInstance(instanceName, `/model ${model}`);
-            return `${warn}✅ Switched ${instanceName} to \`${model}\` (runtime).`;
+            return `${warn}✅ Switched ${instanceName} to \`${model}\` (runtime).${this.effortSuffix(instanceName)}`;
         }
         // restart: persist the model so the respawned CLI launches with it.
         let persisted = false;
@@ -5687,7 +5724,24 @@ When users create specialized instances, suggest these configurations:
         if (!persisted)
             return `${warn}❌ Could not set model for ${instanceName}.`;
         await this.restartSingleInstance(instanceName);
-        return `${warn}✅ Set ${instanceName} to \`${model}\` and restarted.`;
+        return `${warn}✅ Set ${instanceName} to \`${model}\` and restarted.${this.effortSuffix(instanceName)}`;
+    }
+    /**
+     * The trailing "Current effort: …" line for a /model reply.
+     *
+     * Model and effort interact (a cheaper model at max effort is a different
+     * trade than a bigger one at low), so showing the effort in force right after
+     * a switch saves the round trip of asking. Empty when the backend has none.
+     */
+    effortSuffix(instanceName) {
+        if (this.effortLevelsFor(instanceName).length === 0)
+            return "";
+        const { effort, source } = this.resolveInstanceEffort(instanceName);
+        if (!effort)
+            return "\nCurrent effort: (CLI default)";
+        return source === "fleet-default"
+            ? `\nCurrent effort: ${effort} (fleet default)`
+            : `\nCurrent effort: ${effort}`;
     }
     /** Read recent chat log for agent context */
     getRecentChatLog(instanceName, maxLines = 10) {