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

package/dist/fleet-manager.d.ts

@@ -112,6 +112,8 @@ export declare class FleetManager implements FleetContext, LifecycleContext, Arc
     classicChannels: ClassicChannelManager | null;
     private pendingClassicStarts;
     /** In-flight /model selections, keyed by nonce (see handleModelSelection). */
+    /** In-flight /effort selections, same coordinator shape as pendingModelSelects. */
+    private pendingEffortSelects;
     private pendingModelSelects;
     private failoverActive;
     readonly ipcStoppingInstances: Set<string>;
@@ -499,7 +501,7 @@ export declare class FleetManager implements FleetContext, LifecycleContext, Arc
      * 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: number, activity?: string | null): string;
+    static progressText(elapsedMs: number, activity?: string | null, minElapsedMs?: number): string;
     /**
      * Make a tool summary safe to paste into a channel message.
      *
@@ -524,6 +526,8 @@ export declare class FleetManager implements FleetContext, LifecycleContext, Arc
      * 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(): number;
     private startProgressTicker;
     /**
      * After a reply: give the instance REPLY_RETIRE_GRACE_MS to resume working; if
@@ -636,6 +640,15 @@ export declare class FleetManager implements FleetContext, LifecycleContext, Arc
     /** Best-effort model list for `/model`: cached CLI env first, else live probe. Never throws. */
     private getModelOptions;
     /** `/model` slash handler (admin only). No arg → DC menu; `/model <name>` → apply directly. */
+    /** Label an effort choice, marking the one currently configured. */
+    private effortChoiceLabel;
+    private effortMenuHeader;
+    /** `/effort` — DC Select Menu, or apply directly when a level is given. */
+    private handleEffortSlash;
+    /** TG inline-keyboard effort menu. Returns null on success, else a fallback string. */
+    promptEffortMenu(instanceName: string, userId: string, channelId: string, adapter: ChannelAdapter, chatId: string, threadId?: string): Promise<string | null>;
+    /** Consume an `/effort` selection callback. Mirrors handleModelSelection. */
+    private handleEffortSelection;
     private handleModelSlash;
     /**
      * Show a TG inline-keyboard model-selection menu. Reuses the same
@@ -646,7 +659,43 @@ export declare class FleetManager implements FleetContext, LifecycleContext, Arc
     /** Consume a `/model` selection callback. Returns true for all model-select ids (incl. stale). */
     private handleModelSelection;
     /** 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 readonly EFFORT_LEVELS: readonly ["low", "medium", "high", "xhigh", "max"];
+    /** How this instance's backend applies an effort change. */
+    effortStrategyFor(instanceName: string): "runtime" | "restart" | "unsupported";
+    /** Effort levels this instance's backend actually accepts (empty = unsupported). */
+    effortLevelsFor(instanceName: string): string[];
+    /** Configured effort for an instance: per-instance, else fleet default, else none. */
+    resolveInstanceEffort(instanceName: string): {
+        effort: string | null;
+        source: "instance" | "fleet-default" | "unset";
+    };
+    /**
+     * Clamp a canonical level to the nearest one this backend supports.
+     *
+     * Clamping DOWN the ladder, never up: asking for `max` on a CLI that stops at
+     * `high` should get high, not silently fall to low. The caller reports the
+     * clamp — a user who asks for max and quietly receives high has been told the
+     * request succeeded when it did not.
+     */
+    static clampEffort(level: string, supported: string[]): string | null;
+    /**
+     * Apply a reasoning-effort level, mirroring applyModel's shape.
+     *
+     * runtime backends take `/effort <level>` in the pane and keep working;
+     * restart backends only read it at launch, so it is persisted and the
+     * instance respawns.
+     */
+    applyEffort(instanceName: string, requested: string): Promise<string>;
     applyModel(instanceName: string, model: string): Promise<string>;
+    /**
+     * 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.
+     */
+    private effortSuffix;
     /** Read recent chat log for agent context */
     private getRecentChatLog;
     /** Return a user-facing blocker without mutating ClassicBot state. */

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.
  *
@@ -146,6 +151,7 @@ const IPC_RECONNECT_POLL_MS = 250;
 const CLASSIC_BACKEND_SELECTION_TIMEOUT_MS = 60_000;
 const CLASSIC_BACKEND_CALLBACK_PREFIX = "classic-backend:";
 const MODEL_SELECT_CALLBACK_PREFIX = "model-select:";
+const EFFORT_SELECT_CALLBACK_PREFIX = "effort-select:";
 const CLI_ENV_TTL_MS = 24 * 60 * 60 * 1000; // /model reads cached CLI env within 24h
 export class FleetManager {
     dataDir;
@@ -224,6 +230,8 @@ export class FleetManager {
     classicChannels = null;
     pendingClassicStarts = new Map();
     /** In-flight /model selections, keyed by nonce (see handleModelSelection). */
+    /** In-flight /effort selections, same coordinator shape as pendingModelSelects. */
+    pendingEffortSelects = new Map();
     pendingModelSelects = new Map();
     // Model failover state
     failoverActive = new Map(); // instance → current failover model
@@ -1679,6 +1687,8 @@ export class FleetManager {
                 return;
             if (await this.handleModelSelection(data))
                 return;
+            if (await this.handleEffortSelection(data))
+                return;
             if (data.callbackData.startsWith("hang:")) {
                 const parts = data.callbackData.split(":");
                 const action = parts[1];
@@ -1784,6 +1794,9 @@ export class FleetManager {
             else if (data.command === "model") {
                 await this.handleModelSlash(data, adapterId);
             }
+            else if (data.command === "effort") {
+                await this.handleEffortSlash(data, adapterId);
+            }
             else if (data.command === "cancel") {
                 const name = this.resolveSlashTarget(data.channelId, adapterId);
                 if (!name) {
@@ -1987,6 +2000,8 @@ export class FleetManager {
                 return;
             if (await this.handleModelSelection(data))
                 return;
+            if (await this.handleEffortSelection(data))
+                return;
             if (data.callbackData.startsWith("hang:")) {
                 const parts = data.callbackData.split(":");
                 const action = parts[1];
@@ -2079,6 +2094,9 @@ export class FleetManager {
             else if (data.command === "model") {
                 await this.handleModelSlash(data, adapterId);
             }
+            else if (data.command === "effort") {
+                await this.handleEffortSlash(data, adapterId);
+            }
             else if (data.command === "cancel") {
                 const name = this.resolveSlashTarget(data.channelId, adapterId);
                 if (!name) {
@@ -4213,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);
@@ -4265,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;
@@ -4290,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
@@ -5227,6 +5263,170 @@ When users create specialized instances, suggest these configurations:
         return env?.models ?? [];
     }
     /** `/model` slash handler (admin only). No arg → DC menu; `/model <name>` → apply directly. */
+    /** Label an effort choice, marking the one currently configured. */
+    effortChoiceLabel(level, current) {
+        return level === current ? `✓ ${level}` : level;
+    }
+    effortMenuHeader(instanceName) {
+        const { effort, source } = this.resolveInstanceEffort(instanceName);
+        if (!effort)
+            return "Current effort: (CLI default)";
+        return source === "fleet-default"
+            ? `Current effort: ${effort} (fleet default)`
+            : `Current effort: ${effort}`;
+    }
+    /** `/effort` — DC Select Menu, or apply directly when a level is given. */
+    async handleEffortSlash(data, adapterId) {
+        if (!this.isModelAdmin(data.userId, data.channelId, adapterId)) {
+            await data.respond(t("permission.denied"));
+            return;
+        }
+        const name = this.resolveSlashTarget(data.channelId, adapterId);
+        if (!name) {
+            await data.respond(t("classic.no_agent"));
+            return;
+        }
+        const requested = (typeof data.options?.level === "string" ? data.options.level.trim() : "")
+            || (data.text?.trim() ?? "");
+        if (requested) {
+            await data.respond(await this.applyEffort(name, requested));
+            return;
+        }
+        const levels = this.effortLevelsFor(name);
+        if (levels.length === 0) {
+            await data.respond(`❌ ${this.backendNameForInstance(name)} has no reasoning-effort setting.`);
+            return;
+        }
+        if (!data.respondChoices) {
+            await data.respond(`Usage: /effort <${levels.join("|")}>`);
+            return;
+        }
+        const current = this.resolveInstanceEffort(name).effort;
+        const nonce = randomBytes(6).toString("hex");
+        const choices = levels.map(l => ({
+            id: `${EFFORT_SELECT_CALLBACK_PREFIX}${nonce}:${l}`,
+            label: this.effortChoiceLabel(l, current),
+        }));
+        const timer = setTimeout(() => this.pendingEffortSelects.delete(nonce), CLASSIC_BACKEND_SELECTION_TIMEOUT_MS);
+        timer.unref?.();
+        this.pendingEffortSelects.set(nonce, { instanceName: name, userId: data.userId, channelId: data.channelId, timer, respond: data.respond });
+        try {
+            await data.respondChoices(`${this.effortMenuHeader(name)}\nSelect a new effort level:`, choices);
+        }
+        catch (err) {
+            this.pendingEffortSelects.delete(nonce);
+            clearTimeout(timer);
+            this.logger.warn({ err, instanceName: name }, "effort menu failed");
+            await data.respond(`Usage: /effort <${levels.join("|")}>`);
+        }
+    }
+    /** TG inline-keyboard effort menu. Returns null on success, else a fallback string. */
+    async promptEffortMenu(instanceName, userId, channelId, adapter, chatId, threadId) {
+        const levels = this.effortLevelsFor(instanceName);
+        if (levels.length === 0) {
+            return `❌ ${this.backendNameForInstance(instanceName)} has no reasoning-effort setting.`;
+        }
+        const current = this.resolveInstanceEffort(instanceName).effort;
+        const nonce = randomBytes(6).toString("hex");
+        const choices = levels.map(l => ({
+            id: `${EFFORT_SELECT_CALLBACK_PREFIX}${nonce}:${l}`,
+            label: this.effortChoiceLabel(l, current),
+        }));
+        const respond = async (text) => {
+            await adapter.sendText(chatId, text, { threadId });
+            return undefined;
+        };
+        const timer = setTimeout(() => {
+            const p = this.pendingEffortSelects.get(nonce);
+            if (p) {
+                this.pendingEffortSelects.delete(nonce);
+                p.respond("⏰ Effort selection expired.").catch(() => { });
+            }
+        }, CLASSIC_BACKEND_SELECTION_TIMEOUT_MS);
+        timer.unref?.();
+        this.pendingEffortSelects.set(nonce, { instanceName, userId, channelId, timer, respond, adapter, adapterChatId: chatId, adapterThreadId: threadId });
+        try {
+            const menuMessageId = await adapter.promptUser(chatId, `${this.effortMenuHeader(instanceName)}\nSelect a new effort level:`, choices, { threadId });
+            const pending = this.pendingEffortSelects.get(nonce);
+            if (pending)
+                pending.menuMessageId = menuMessageId;
+            return null;
+        }
+        catch (err) {
+            this.pendingEffortSelects.delete(nonce);
+            clearTimeout(timer);
+            this.logger.warn({ err, instanceName }, "TG effort menu failed");
+            return `Usage: /effort <${levels.join("|")}>`;
+        }
+    }
+    /** Consume an `/effort` selection callback. Mirrors handleModelSelection. */
+    async handleEffortSelection(data) {
+        if (!data.callbackData.startsWith(EFFORT_SELECT_CALLBACK_PREFIX))
+            return false;
+        const match = data.callbackData.match(/^effort-select:([0-9a-f]+):(.+)$/);
+        if (!match)
+            return true;
+        const pending = this.pendingEffortSelects.get(match[1]);
+        if (!pending)
+            return true;
+        if (data.userId && data.userId !== pending.userId)
+            return true;
+        const cbChannel = data.threadId ?? data.chatId;
+        if (cbChannel !== pending.channelId && data.chatId !== pending.channelId)
+            return true;
+        this.pendingEffortSelects.delete(match[1]);
+        clearTimeout(pending.timer);
+        const level = match[2];
+        const progressText = `⏳ Setting ${pending.instanceName} effort to \`${level}\`…`;
+        let progressMsgId;
+        if (pending.adapter && pending.adapterChatId) {
+            const menuMessageId = pending.menuMessageId ?? data.messageId;
+            if (menuMessageId && pending.adapter.editMessageRemoveButtons) {
+                try {
+                    await pending.adapter.editMessageRemoveButtons(pending.adapterChatId, menuMessageId, progressText, pending.adapterThreadId);
+                    progressMsgId = menuMessageId;
+                }
+                catch { /* fall back to a new message */ }
+            }
+            if (!progressMsgId) {
+                try {
+                    const sent = await pending.adapter.sendText(pending.adapterChatId, progressText, { threadId: pending.adapterThreadId });
+                    progressMsgId = sent.messageId;
+                }
+                catch { /* non-fatal */ }
+            }
+        }
+        else {
+            await pending.respond(progressText).catch(() => { });
+        }
+        // Background-applied and guarded for the same reason as the model path: a
+        // restart backend respawns the instance here, and an unguarded rejection
+        // from a menu click must not take the fleet down.
+        void (async () => {
+            let result;
+            try {
+                result = await this.applyEffort(pending.instanceName, level);
+            }
+            catch (err) {
+                this.logger.error({ err, instance: pending.instanceName, level }, "Effort switch failed");
+                result = `Effort switch to \`${level}\` failed: ${err instanceof Error ? err.message : String(err)}`;
+            }
+            if (pending.adapter && pending.adapterChatId) {
+                if (progressMsgId) {
+                    pending.adapter.editMessage(pending.adapterChatId, progressMsgId, result, pending.adapterThreadId).catch(() => {
+                        pending.adapter.sendText(pending.adapterChatId, result, { threadId: pending.adapterThreadId }).catch(() => { });
+                    });
+                }
+                else {
+                    pending.adapter.sendText(pending.adapterChatId, result, { threadId: pending.adapterThreadId }).catch(() => { });
+                }
+            }
+            else {
+                await pending.respond(result).catch(() => { });
+            }
+        })();
+        return true;
+    }
     async handleModelSlash(data, adapterId) {
         if (!this.isModelAdmin(data.userId, data.channelId, adapterId)) {
             await data.respond(t("permission.denied"));
@@ -5393,6 +5593,110 @@ When users create specialized instances, suggest these configurations:
         return true;
     }
     /** 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 {
+            const backend = createBackend(this.backendNameForInstance(instanceName), this.getInstanceDir(instanceName));
+            if ((backend.getEffortStrategy?.() ?? "unsupported") === "unsupported")
+                return [];
+            return backend.getEffortLevels?.() ?? [];
+        }
+        catch {
+            return [];
+        }
+    }
+    /** Configured effort for an instance: per-instance, else fleet default, else none. */
+    resolveInstanceEffort(instanceName) {
+        const own = this.fleetConfig?.instances[instanceName]?.effort;
+        if (own)
+            return { effort: own, source: "instance" };
+        const fallback = this.fleetConfig?.defaults?.effort;
+        if (fallback)
+            return { effort: fallback, source: "fleet-default" };
+        return { effort: null, source: "unset" };
+    }
+    /**
+     * Clamp a canonical level to the nearest one this backend supports.
+     *
+     * Clamping DOWN the ladder, never up: asking for `max` on a CLI that stops at
+     * `high` should get high, not silently fall to low. The caller reports the
+     * clamp — a user who asks for max and quietly receives high has been told the
+     * request succeeded when it did not.
+     */
+    static clampEffort(level, supported) {
+        if (supported.includes(level))
+            return level;
+        const ladder = FleetManager.EFFORT_LEVELS;
+        const wanted = ladder.indexOf(level);
+        if (wanted < 0)
+            return null;
+        for (let i = wanted - 1; i >= 0; i--) {
+            if (supported.includes(ladder[i]))
+                return ladder[i];
+        }
+        return supported[0] ?? null;
+    }
+    /**
+     * Apply a reasoning-effort level, mirroring applyModel's shape.
+     *
+     * runtime backends take `/effort <level>` in the pane and keep working;
+     * restart backends only read it at launch, so it is persisted and the
+     * instance respawns.
+     */
+    async applyEffort(instanceName, requested) {
+        const level = requested.trim().toLowerCase();
+        const backendName = this.backendNameForInstance(instanceName);
+        let strategy = "unsupported";
+        let supported = [];
+        try {
+            const backend = createBackend(backendName, this.getInstanceDir(instanceName));
+            strategy = backend.getEffortStrategy?.() ?? "unsupported";
+            supported = backend.getEffortLevels?.() ?? [];
+        }
+        catch { /* treated as unsupported below */ }
+        if (strategy === "unsupported" || supported.length === 0) {
+            return `❌ ${backendName} has no reasoning-effort setting.`;
+        }
+        if (!FleetManager.EFFORT_LEVELS.includes(level)) {
+            return `❌ Unknown effort level \`${level}\`. Use: ${FleetManager.EFFORT_LEVELS.join(", ")}.`;
+        }
+        const applied = FleetManager.clampEffort(level, supported);
+        if (!applied)
+            return `❌ ${backendName} accepts none of the canonical effort levels.`;
+        const warn = applied === level
+            ? ""
+            : `⚠️ Clamped to \`${applied}\` (\`${level}\` not supported by ${backendName}).\n`;
+        // Persist either way: a runtime switch must survive the next respawn too,
+        // or the instance silently reverts on restart.
+        if (this.fleetConfig?.instances[instanceName]) {
+            this.fleetConfig.instances[instanceName].effort = applied;
+            this.saveFleetConfig();
+        }
+        if (strategy === "runtime") {
+            if (!this.instanceIpcClients.get(instanceName))
+                return `${warn}❌ ${instanceName} is not running.`;
+            this.pasteRawToClassicInstance(instanceName, `/effort ${applied}`);
+            return `${warn}✅ Set ${instanceName} effort to \`${applied}\` (runtime).`;
+        }
+        await this.restartSingleInstance(instanceName);
+        return `${warn}✅ Set ${instanceName} effort to \`${applied}\` and restarted.`;
+    }
     async applyModel(instanceName, model) {
         const backendName = this.backendNameForInstance(instanceName);
         let strategy = "restart";
@@ -5405,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;
@@ -5420,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) {