@songsid/agend 2.1.11 → 2.1.12-beta.2

package/dist/fleet-manager.js

@@ -26,6 +26,7 @@ import { loadFleetConfig, loadRawFleetConfig, DEFAULT_COST_GUARD, DEFAULT_DAILY_
 import { EventLog } from "./event-log.js";
 import { AdapterWorld } from "./adapter-world.js";
 import { CostGuard, formatCents } from "./cost-guard.js";
+import { startEventLoopWatch } from "./event-loop-watch.js";
 import { TmuxManager } from "./tmux-manager.js";
 import { AccessManager } from "./channel/access-manager.js";
 import { IpcClient } from "./channel/ipc-bridge.js";
@@ -75,6 +76,7 @@ import { handleAgentRequest, ToolNotPermittedError } from "./agent-endpoint.js";
 import { ClassicChannelManager, getClassicBackendChoices, isSelectableClassicBackend, readClassicLastActivityAt } from "./classic-channel-manager.js";
 import { assertExplicitInstanceRemoval } from "./instance-removal.js";
 import { validateFleetConfig } from "./config-validator.js";
+import { presentationState, interactionSummary } from "./interaction-observation.js";
 import { readLastInboundAt } from "./daemon.js";
 import { clearPausedMarker, readPausedAt, readPauseReason, writePausedMarker } from "./pause-marker.js";
 import { DEFAULT_WARM_OVERFLOW, WakeCoordinator } from "./wake-coordinator.js";
@@ -97,7 +99,8 @@ import { PROVIDER_SECRET_SPECS, providerSecretSpec, providerRegistryEnvKeys, isR
 /** A self-restart is a whole service restart; 120s is the apply budget, not this. */
 const SELF_RESTART_DEADLINE_MS = 300_000;
 import { APPLY_FLEET_TARGET, ApplyJobStore, viewOf, } from "./apply-job.js";
-import { instanceCredentialProfile } from "./backend/credential-profile.js";
+import { credentialSwitchStartsFresh, instanceCredentialProfile } from "./backend/credential-profile.js";
+import { mergeBackendOptions, profileKey, profileName, profileOf } from "./classic-bindings.js";
 import { classifyInstanceChange, CLASSIC_HOT_CONFIG_KEYS, HOT_INSTANCE_CONFIG_KEYS, hotConfigUpdate, } from "./instance-config-impact.js";
 import { formatRestartProgressCompletion, RESTART_PROGRESS_TERMINAL_TIMEOUT_MS, RestartProgress, } from "./restart-progress.js";
 import { launchFullRestartHelper } from "./full-restart.js";
@@ -297,6 +300,21 @@ export function deriveSpawnConcurrency(freeMemMB, cores) {
 const REPLY_OBLIGATION_SWEEP_MS = 30_000;
 const REPLY_REMINDER_GRACE_MS = 60_000;
 const DEFAULT_REPLY_OVERDUE_MINUTES = 15;
+/**
+ * The filter `list_emojis` and `list_stickers` take (#1226). Values may come from the agent CLI as strings, so a
+ * limit is read as a number and the flags accept "true". No limit means all of them — never zero.
+ */
+function emojiListFilter(opts) {
+    const name = typeof opts.name === "string" ? opts.name.trim().toLowerCase() : "";
+    const n = Number(opts.limit);
+    const flag = (v) => v === true || v === "true";
+    return {
+        matches: (...texts) => !name || texts.some(t => t.toLowerCase().includes(name)),
+        limit: Number.isInteger(n) && n >= 1 ? n : Infinity,
+        primaryOnly: flag(opts.primary_only),
+        withImageUrls: flag(opts.with_image_urls),
+    };
+}
 export class FleetManager {
     dataDir;
     static signalTarget = null;
@@ -550,6 +568,7 @@ export class FleetManager {
     /** Days of event/activity history to keep. */
     static EVENT_LOG_RETENTION_DAYS = 30;
     watchdogTimer = null;
+    eventLoopWatch = null;
     startedAt = 0;
     stormOpenNotifyTimer = null;
     memoryLogAt = null;
@@ -1774,6 +1793,21 @@ export class FleetManager {
             return null;
         return this.instanceStateCache.get(name)?.state ?? null;
     }
+    /** Pure read of the single daemon-owned observation; no probe/capture or second tracker. */
+    getInstanceInteraction(name) {
+        if (this.lifecycle.isPaused(name) || this.instanceProcessStatus.has(name))
+            return null;
+        const daemon = this.lifecycle.daemons.get(name);
+        if (daemon?.getProcessStatus?.() !== "running")
+            return null;
+        return daemon.getInteractionSnapshot?.() ?? null;
+    }
+    instancePresentation(name) {
+        const execution_state = this.getInstanceExecutionState(name);
+        const interaction = this.getInstanceInteraction(name);
+        return { state: presentationState(execution_state, interaction), execution_state,
+            interaction, interaction_summary: interactionSummary(interaction) };
+    }
     /**
      * Subscription providers currently relevant to this fleet. Stopped/crashed
      * rows do not keep a usage card alive, while persisted paused instances do.
@@ -1805,6 +1839,34 @@ export class FleetManager {
         }
         return providers;
     }
+    /** #1220: the login a running classic instance was launched on, from its own config; null when not running. */
+    classicLaunchedProfile(name) {
+        const launched = this.daemons.get(name)?.getConfigSnapshot?.();
+        return launched ? profileOf(launched.backend_options, launched.backend ?? "claude-code") : null;
+    }
+    /**
+     * #1220: whether a running classic instance's login differs from what its
+     * configuration now says — compared with what it was launched on, not with an
+     * earlier reading of the config (a reload consumes that), and with an invalid
+     * setting as a value of its own rather than the shared login it would fall to.
+     * A switch on the same backend that loses the conversation (kiro) starts fresh.
+     */
+    classicProfileChange(name, backendChanged) {
+        const launched = this.classicLaunchedProfile(name);
+        if (!launched || !this.classicChannels)
+            return { changed: false, startsFresh: false };
+        const next = this.classicChannels.getCredentialProfileByInstance(name, this.fleetConfig?.defaults);
+        if (profileKey(launched) === profileKey(next))
+            return { changed: false, startsFresh: false };
+        const backend = this.classicChannels.getBackendByInstance(name, this.fleetConfig?.defaults?.backend);
+        return {
+            changed: true,
+            // A backend change keeps its own (existing) restart semantics.
+            startsFresh: !backendChanged && credentialSwitchStartsFresh(backend),
+            from: profileKey(launched),
+            to: profileKey(next),
+        };
+    }
     /** `[instance, effective backend, credential profile]` for everything that is
      * running or paused — the one place both usage views agree on who is live. */
     activeBackendBindings() {
@@ -1823,8 +1885,9 @@ export class FleetManager {
         }
         for (const channel of this.classicChannels?.getAll() ?? []) {
             const backend = this.classicChannels?.getBackendByInstance(channel.instanceName, this.fleetConfig?.defaults?.backend);
-            // Classic channels carry no backend_options, so they run the shared login.
-            add(channel.instanceName, backend, null);
+            // The login it was launched on; before a launch, the one it would get (#1220).
+            add(channel.instanceName, backend, profileName(this.classicLaunchedProfile(channel.instanceName)
+                ?? this.classicChannels.getCredentialProfileByInstance(channel.instanceName, this.fleetConfig?.defaults)));
         }
         return bindings;
     }
@@ -2693,9 +2756,15 @@ export class FleetManager {
                 const backendChanged = oldBackends.get(ch.instanceName) !== newBackend;
                 const modelChanged = oldModels.get(ch.instanceName) !== newModel;
                 const autoPauseChanged = oldAutoPause.get(ch.instanceName) !== newAutoPause;
-                if (this.daemons.has(ch.instanceName) && (backendChanged || modelChanged || autoPauseChanged)) {
-                    this.logger.info({ instanceName: ch.instanceName, backendFrom: oldBackends.get(ch.instanceName), backendTo: newBackend, modelFrom: oldModels.get(ch.instanceName), modelTo: newModel }, "Backend/model changed — restarting");
+                // #1220: a running CLI keeps the login it was launched with, so a new
+                // credential_profile only takes effect through a restart.
+                const { changed: profileChanged, startsFresh: profileSwitchStartsFresh, from: profileFrom, to: profileTo } = this.classicProfileChange(ch.instanceName, backendChanged);
+                if (this.daemons.has(ch.instanceName) && (backendChanged || modelChanged || autoPauseChanged || profileChanged)) {
+                    this.logger.info({ instanceName: ch.instanceName, backendFrom: oldBackends.get(ch.instanceName), backendTo: newBackend, modelFrom: oldModels.get(ch.instanceName), modelTo: newModel,
+                        ...(profileChanged ? { profileFrom, profileTo } : {}) }, "Backend/model/profile changed — restarting");
                     await this.stopInstance(ch.instanceName).catch(() => { });
+                    if (profileSwitchStartsFresh)
+                        this.writeFreshStartMarker(ch.instanceName);
                     // Small delay to let tmux window clean up
                     await new Promise(r => setTimeout(r, 2000));
                     // The manager already holds the new backend/model/auto-pause; the
@@ -4012,6 +4081,10 @@ export class FleetManager {
         // instance would get a restart loop. Those conditions surface through /health
         // (which now returns 503) and through the General-topic notifications instead.
         this.watchdogTimer = setInterval(() => sdNotify("WATCHDOG=1"), 30_000);
+        // #1231: a stalled loop is what turns a slash command into "did not respond";
+        // put each long stall in the log instead of leaving it to be guessed at.
+        this.eventLoopWatch?.stop();
+        this.eventLoopWatch = startEventLoopWatch({ logger: this.logger });
         // EventLog.prune() existed but was never called, so `events` and `activity`
         // grew without bound for the life of the install. Prune once at startup and
         // daily after that; the timer is unref'd so it never holds the loop open.
@@ -5897,7 +5970,16 @@ export class FleetManager {
         // still in flight and about to succeed. One real send, everyone gets its
         // outcome; a genuinely failed send clears the entry so a retry passes.
         if (tool === "reply") {
-            const ticket = this.replyDeduper.begin(instanceName, String(args.text ?? ""), Array.isArray(args.files) ? args.files : []);
+            // Stickers (#1226) are checked before anything is sent: a refused one is the reply's error, not a gap.
+            const stickerProblem = await this.replyStickerProblem(outAdapter, args, threadId, contextAdapterId ?? this.getInstanceAdapterId(senderInstanceName ?? instanceName));
+            if (stickerProblem) {
+                respond(null, stickerProblem);
+                return;
+            }
+            const stickers = Array.isArray(args.stickers) ? args.stickers : [];
+            const ticket = this.replyDeduper.begin(instanceName, 
+            // A reply with stickers is not the same reply as its text alone.
+            stickers.length ? `${String(args.text ?? "")}\u0000stickers:${stickers.join(",")}` : String(args.text ?? ""), Array.isArray(args.files) ? args.files : []);
             if (ticket.duplicate) {
                 this.logger.info({ instanceName }, "Concurrent duplicate reply joined — awaiting the original send's outcome");
                 ticket.subscribe(respond);
@@ -6188,7 +6270,8 @@ export class FleetManager {
             : type.startsWith("fleet_decision_") ? "fleet_decision_response"
                 : type === "fleet_task" ? "fleet_task_response"
                     : type === "fleet_set_display_name" ? "fleet_display_name_response"
-                        : type === "fleet_list_emojis" || type === "fleet_set_persona_emoji" || type === "fleet_preview_emojis" ? "fleet_persona_emoji_response"
+                        : type === "fleet_list_emojis" || type === "fleet_set_persona_emoji" || type === "fleet_preview_emojis"
+                            || type === "fleet_list_stickers" || type === "fleet_preview_stickers" ? "fleet_persona_emoji_response"
                             : "fleet_description_response";
         ipc.send({ type: responseType, fleetRequestId, error: message });
     }
@@ -6214,21 +6297,24 @@ export class FleetManager {
             this.handleSetDescription(name, msg);
             return;
         }
-        if (type === "fleet_list_emojis" || type === "fleet_set_persona_emoji" || type === "fleet_preview_emojis") {
+        if (type === "fleet_list_emojis" || type === "fleet_set_persona_emoji" || type === "fleet_preview_emojis"
+            || type === "fleet_list_stickers" || type === "fleet_preview_stickers") {
             this.handlePersonaEmoji(name, msg);
             return;
         }
     }
-    /** `list_emojis` / `set_persona_emoji` / `preview_emojis` over IPC; the agent endpoint calls the same methods. */
+    /** `list_emojis` / `set_persona_emoji` / `preview_emojis` / `list_stickers` / `preview_stickers` over IPC; the agent endpoint calls the same methods. */
     handlePersonaEmoji(instanceName, msg) {
         const fleetRequestId = msg.fleetRequestId;
         const payload = (msg.payload ?? {});
         const ipc = this.instanceIpcClients.get(instanceName);
         if (!ipc)
             return;
-        const op = msg.type === "fleet_list_emojis" ? this.listEmojisFor(instanceName, payload.refresh === true)
+        const op = msg.type === "fleet_list_emojis" ? this.listEmojisFor(instanceName, payload.refresh === true, payload)
             : msg.type === "fleet_preview_emojis" ? this.previewEmojis(instanceName, payload)
-                : this.setPersonaEmoji(instanceName, payload);
+                : msg.type === "fleet_list_stickers" ? this.listStickersFor(instanceName, payload)
+                    : msg.type === "fleet_preview_stickers" ? this.previewStickers(instanceName, payload)
+                        : this.setPersonaEmoji(instanceName, payload);
         op.then((r) => typeof r.error === "string"
             ? ipc.send({ type: "fleet_persona_emoji_response", fleetRequestId, error: r.error })
             : ipc.send({ type: "fleet_persona_emoji_response", fleetRequestId, result: r }), (err) => ipc.send({ type: "fleet_persona_emoji_response", fleetRequestId, error: err.message }));
@@ -6579,8 +6665,14 @@ export class FleetManager {
             return { error: `Instance '${instance}' not found` };
         return { display_name: name };
     }
-    async handleListEmojisHttp(instance, refresh) {
-        return this.listEmojisFor(instance, refresh);
+    async handleListEmojisHttp(instance, refresh, args = {}) {
+        return this.listEmojisFor(instance, refresh, args);
+    }
+    async handleListStickersHttp(instance, args) {
+        return this.listStickersFor(instance, args);
+    }
+    async handlePreviewStickersHttp(instance, args) {
+        return this.previewStickers(instance, args);
     }
     async handleSetPersonaEmojiHttp(instance, args) {
         return this.setPersonaEmoji(instance, args);
@@ -7311,7 +7403,7 @@ export class FleetManager {
      * bot can draw on — the same lists, and the same resolution, as the
      * Settings picker (#1005/#1021), so an agent and an operator see one truth.
      */
-    async listEmojisFor(instanceName, refresh = false) {
+    async listEmojisFor(instanceName, refresh = false, opts = {}) {
         // Seeing is not setting: a ClassicBot instance has no per-instance stamp,
         // but it reacts in its own channel like any bot and must be able to see
         // the emojis it can use (only set_persona_emoji refuses it).
@@ -7334,18 +7426,25 @@ export class FleetManager {
             ...(classic ? { note: "ClassicBot instances have no per-instance status emojis: the statuses above are the connection's, which an operator sets in Settings. You can still use any emoji listed here in your own reactions." } : {}),
         };
         if (platform === "discord" && worldId) {
+            // #1226: a busy server's list was ~10k characters for an agent that wanted one emoji. Filter by name, cap
+            // the count, keep to the primary server if asked, and leave the image URLs out unless asked
+            // (preview_emojis is how an agent looks at one).
+            const filter = emojiListFilter(opts);
             const listed = await this.listGuildEmojis(worldId, refresh);
+            let left = filter.limit;
             out.server_emojis = listed.ok
-                ? listed.guilds.map(g => g.emojis
+                ? listed.guilds.filter(g => !filter.primaryOnly || g.primary).map(g => g.emojis
                     ? {
                         server: g.name || g.id, primary: g.primary,
-                        emojis: g.emojis.filter(e => e.available).map(e => {
+                        emojis: g.emojis.filter(e => e.available && filter.matches(e.name)).filter(() => left-- > 0).map(e => {
                             const value = customEmojiValue(e);
-                            return { value, image_url: emojiImageUrl(value) };
+                            return filter.withImageUrls ? { value, image_url: emojiImageUrl(value) } : { value };
                         }),
                     }
                     : { server: g.name || g.id, primary: g.primary, error: g.error })
                 : { error: listed.error };
+            if (!filter.withImageUrls)
+                out.server_emojis_note = "Image URLs are left out; preview_emojis downloads the ones you want to look at (or pass with_image_urls).";
         }
         return out;
     }
@@ -7403,6 +7502,193 @@ export class FleetManager {
         }
         return { previews, errors, note: "Read each path to see the emoji (a static PNG)." };
     }
+    // ── Stickers (#1226) ─────────────────────────────────────────────────────
+    /** Where an instance talks: its connection, and its chat (and topic). The same address its notices go to. */
+    instanceChatTarget(instanceName) {
+        const worldId = this.getInstanceAdapterId(instanceName);
+        const adapter = (worldId ? this.worlds.get(worldId)?.adapter : undefined) ?? this.getAdapterForInstance(instanceName) ?? this.adapter ?? undefined;
+        const topic = this.fleetConfig?.instances[instanceName]?.topic_id;
+        const groupId = this.getChannelConfig(worldId)?.group_id;
+        if (topic != null && groupId != null)
+            return { worldId, adapter, chatId: String(groupId), threadId: String(topic) };
+        const classicChat = this.classicChannels?.getChannelIdByInstance(instanceName);
+        return { worldId, adapter, chatId: classicChat ?? (groupId != null ? String(groupId) : undefined) };
+    }
+    static STICKER_LIST_TTL_MS = 10 * 60_000;
+    /** Keyed `<connection>\0<scope key>` (a Discord channel, or "set:<name>"). */
+    stickerCache = new Map();
+    /** One sticker list through the adapter, cached; `refresh` forces a fetch. Errors are the platform's, reworded. */
+    async stickerListFor(worldId, adapter, target, refresh = false) {
+        const key = `${worldId}\0${target.set ? `set:${target.set}` : `chat:${target.threadId ?? target.chatId ?? ""}`}`;
+        const cached = this.stickerCache.get(key);
+        if (!refresh && cached && Date.now() - cached.fetched_at < FleetManager.STICKER_LIST_TTL_MS)
+            return cached.list;
+        const list = await adapter.listStickers(target);
+        this.stickerCache.set(key, { fetched_at: Date.now(), list });
+        return list;
+    }
+    /** The Telegram sticker sets an instance lists by default: its connection's `options.sticker_sets`. */
+    defaultStickerSets(worldId) {
+        const sets = this.getChannelConfig(worldId)?.options?.sticker_sets;
+        return Array.isArray(sets) ? sets.filter((x) => typeof x === "string" && x.trim() !== "").slice(0, 10) : [];
+    }
+    /**
+     * `list_stickers` (#1226): the stickers this instance can send where it talks, one shape on both platforms —
+     * `{ id, name, emoji_or_tags, format }` and no image URLs (preview_stickers shows them). Discord: its channel's
+     * server only — a bot cannot send another server's stickers, so listing them would only cost context.
+     * Telegram: the set named, or the connection's `options.sticker_sets`.
+     */
+    async listStickersFor(instanceName, args) {
+        if (!this.ownInstanceConfig(instanceName) && !this.isClassicPersonaTarget(instanceName)) {
+            return { error: this.personaEmojiMissing(instanceName) };
+        }
+        const { worldId, adapter, chatId, threadId } = this.instanceChatTarget(instanceName);
+        if (!worldId || !adapter?.listStickers)
+            return { error: "this channel has no stickers to list" };
+        const filter = emojiListFilter(args);
+        const refresh = args.refresh === true || args.refresh === "true";
+        const telegram = adapter.type === "telegram";
+        const requested = typeof args.set === "string" && args.set.trim() ? [args.set.trim()] : [];
+        const sets = telegram ? (requested.length ? requested : this.defaultStickerSets(worldId)) : [];
+        if (telegram && !sets.length) {
+            return { error: "name a sticker set: set=<name> (the <name> in t.me/addstickers/<name>), or have an operator add options.sticker_sets to this connection" };
+        }
+        const targets = telegram ? sets.map(set => ({ set })) : [{ chatId, threadId }];
+        const lists = [];
+        let left = filter.limit;
+        for (const target of targets) {
+            try {
+                const list = await this.stickerListFor(worldId, adapter, target, refresh);
+                const stickers = list.stickers
+                    .filter(st => st.available && filter.matches(st.name, st.emoji_or_tags))
+                    .filter(() => left-- > 0)
+                    .map(({ id, name, emoji_or_tags, format }) => ({ id, name, emoji_or_tags, format }));
+                lists.push({ scope: list.scope, stickers });
+            }
+            catch (err) {
+                lists.push({ scope: target.set ? `set ${target.set}` : "this server", error: `cannot list stickers: ${err.message}` });
+            }
+        }
+        return {
+            platform: adapter.type,
+            lists,
+            note: "Send one with reply({ stickers: [id] }) — up to 3, never in the text. preview_stickers shows what they look like.",
+        };
+    }
+    /**
+     * `preview_stickers` (#1226), the sticker twin of preview_emojis: the fleet downloads a still picture of each named
+     * sticker and returns a local path to Read. Only ids this instance's list_stickers returned (from the cache it
+     * filled) — nothing the caller writes reaches a URL. A Lottie sticker, or an animated one with no thumbnail, has no
+     * still picture: it is listed as preview_unavailable.
+     */
+    async previewStickers(instanceName, args) {
+        if (!this.ownInstanceConfig(instanceName) && !this.isClassicPersonaTarget(instanceName)) {
+            return { error: this.personaEmojiMissing(instanceName) };
+        }
+        const wanted = args.stickers;
+        if (!Array.isArray(wanted) || wanted.length === 0 || wanted.some(x => typeof x !== "string" || !x)) {
+            return { error: "stickers is required: a list of ids from list_stickers" };
+        }
+        if (wanted.length > FleetManager.EMOJI_PREVIEW_MAX)
+            return { error: `at most ${FleetManager.EMOJI_PREVIEW_MAX} at a time: narrow them down by name first` };
+        const { worldId, adapter } = this.instanceChatTarget(instanceName);
+        if (!worldId || !adapter?.fetchStickerPreview)
+            return { error: "this channel has no stickers to preview" };
+        const known = new Map();
+        for (const [key, entry] of this.stickerCache) {
+            if (key.startsWith(`${worldId}\0`))
+                for (const st of entry.list.stickers)
+                    known.set(st.id, st);
+        }
+        const previews = [];
+        const unavailable = [];
+        const errors = [];
+        // In parallel: eight sequential downloads could outlast the tool's budget.
+        const outcomes = await Promise.all(wanted.map(async (id) => {
+            const st = known.get(id);
+            if (!st)
+                return { id, error: "not a sticker list_stickers returned here; list them first" };
+            try {
+                return { id, st, picture: await adapter.fetchStickerPreview(st) };
+            }
+            catch (err) {
+                return { id, error: `download failed: ${err.message}` };
+            }
+        }));
+        for (const o of outcomes) {
+            if ("error" in o) {
+                errors.push({ sticker: o.id, error: o.error });
+                continue;
+            }
+            if (!o.picture) {
+                unavailable.push({ sticker: o.id, name: o.st.name, reason: `preview_unavailable: a ${o.st.format} sticker has no still picture` });
+                continue;
+            }
+            previews.push({ sticker: o.id, name: o.st.name, path: this.storeStickerPreview(o.id, o.picture) });
+        }
+        return { previews, unavailable, errors, note: "Read each path to see the sticker (a still picture)." };
+    }
+    /** A preview under the inbox, named by a hash of the id (a Telegram file_id is long), pruned after a day. */
+    storeStickerPreview(id, picture) {
+        const dir = join(this.dataDir, "inbox", "sticker-previews");
+        mkdirSync(dir, { recursive: true });
+        const now = Date.now();
+        for (const name of readdirSync(dir)) {
+            try {
+                if (now - statSync(join(dir, name)).mtimeMs > FleetManager.EMOJI_PREVIEW_TTL_MS)
+                    unlinkSync(join(dir, name));
+            }
+            catch { /* raced */ }
+        }
+        const path = join(dir, `${createHash("sha256").update(id).digest("hex").slice(0, 24)}.${picture.ext}`);
+        const tmp = `${path}.${process.pid}.tmp`;
+        writeFileSync(tmp, picture.bytes);
+        renameSync(tmp, path);
+        return path;
+    }
+    /**
+     * `reply.stickers` (#1226), checked before anything is sent — a refused sticker is an error the agent sees, never
+     * a reply that silently arrives without it. At most 3, text or stickers required. Discord: each must be an available
+     * sticker of the server the reply goes to (another server's cannot be sent). Telegram: any sticker's file_id can be
+     * sent anywhere; only its shape is checked here, and Telegram's own refusal still comes back as the reply's error.
+     */
+    async replyStickerProblem(adapter, args, threadId, worldId) {
+        const raw = args.stickers;
+        const hasText = typeof args.text === "string" && args.text.length > 0;
+        if (raw === undefined || (Array.isArray(raw) && raw.length === 0))
+            return hasText ? null : "reply: text is required (or stickers)";
+        if (!Array.isArray(raw) || raw.some(x => typeof x !== "string" || !x.trim()))
+            return "reply: stickers must be a list of sticker ids from list_stickers";
+        const ids = raw;
+        if (ids.length > 3)
+            return "reply: at most 3 stickers per message";
+        if (new Set(ids).size !== ids.length)
+            return "reply: the same sticker twice";
+        if (!adapter.sendStickers || !adapter.listStickers)
+            return "reply: this channel cannot send stickers";
+        if (adapter.type === "telegram") {
+            const bad = ids.find(id => !/^[A-Za-z0-9_-]{10,255}$/.test(id));
+            return bad ? `reply: ${bad} is not a Telegram sticker id (use an id from list_stickers)` : null;
+        }
+        const target = { chatId: typeof args.chat_id === "string" ? args.chat_id : undefined, threadId };
+        let list;
+        try {
+            list = await this.stickerListFor(worldId ?? adapter.id ?? adapter.type, adapter, target);
+            if (ids.some(id => !list.stickers.some(st => st.id === id)))
+                list = await this.stickerListFor(worldId ?? adapter.id ?? adapter.type, adapter, target, true);
+        }
+        catch (err) {
+            return `reply: cannot check the stickers for this channel: ${err.message}`;
+        }
+        for (const id of ids) {
+            const st = list.stickers.find(x => x.id === id);
+            if (!st)
+                return `reply: sticker ${id} cannot be sent here — only stickers of this channel's server can (${list.scope}); call list_stickers`;
+            if (!st.available)
+                return `reply: sticker ${st.name} (${id}) is unavailable on this server (it lost the boost level it needs)`;
+        }
+        return null;
+    }
     static EMOJI_PREVIEW_MAX = 8;
     static EMOJI_PREVIEW_MAX_BYTES = 256 * 1024;
     static EMOJI_PREVIEW_TTL_MS = 24 * 60 * 60_000;
@@ -12123,6 +12409,17 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
             ...(autoPauseAfter !== undefined ? { auto_pause_after: autoPauseAfter } : {}),
             ...(preTaskCommand ? { pre_task_command: preTaskCommand } : {}),
         };
+        // #1220: a channel's own backend_options (credential_profile) override the
+        // fleet defaults' per backend, as a fleet.yaml instance's do.
+        config.backend_options = mergeBackendOptions(config.backend_options, classicIdentity?.backendOptions);
+        // ClassicBot has no validator in front of its launch, and a backend that
+        // cannot read a profile name falls back to the shared login. Refuse here,
+        // so a bad name never runs the agent on the wrong subscription.
+        const profile = profileOf(config.backend_options, config.backend ?? "claude-code");
+        if (profile.state === "invalid") {
+            throw new Error(`Classic instance '${instanceName}' has an invalid credential_profile (${profile.reason}) — `
+                + "fix it in classicBot.yaml; it will not start on another login");
+        }
         const topicMode = this.fleetConfig?.channel?.mode === "topic";
         await this.startInstance(instanceName, config, topicMode, "classic", false, transition);
     }
@@ -12209,6 +12506,8 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
             clearInterval(this.watchdogTimer);
             this.watchdogTimer = null;
         }
+        this.eventLoopWatch?.stop();
+        this.eventLoopWatch = null;
         // A login/install window is a dedicated tmux server with its own TTL
         // timer and HTTP listener living in THIS process: without an explicit
         // shutdown it would outlive us as an owner-less login CLI (sol B3).
@@ -12631,10 +12930,13 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
                 const backend = this.classicChannels.getBackend(ch.channelId, ch.adapterId, this.fleetConfig?.defaults?.backend);
                 const model = this.classicChannels.getModel(ch.channelId, ch.adapterId, this.fleetConfig?.defaults?.model);
                 const autoPauseAfter = this.classicChannels.getAutoPauseAfter(ch.channelId, ch.adapterId, this.fleetConfig?.defaults?.auto_pause_after);
-                if (old.backend !== backend || old.model !== model || old.autoPauseAfter !== autoPauseAfter) {
-                    this.logger.info({ instanceName: ch.instanceName }, "Classic cold config changed — restarting");
+                const profile = this.classicProfileChange(ch.instanceName, old.backend !== backend);
+                if (old.backend !== backend || old.model !== model || old.autoPauseAfter !== autoPauseAfter || profile.changed) {
+                    this.logger.info({ instanceName: ch.instanceName, ...(profile.changed ? { profileFrom: profile.from, profileTo: profile.to } : {}) }, "Classic cold config changed — restarting");
                     observe?.(ch.instanceName, "restart", "running");
                     await this.stopInstance(ch.instanceName).catch(() => { });
+                    if (profile.startsFresh)
+                        this.writeFreshStartMarker(ch.instanceName);
                     await this.startClassicInstanceUnattended(ch, "classic instance after fleet reload");
                     observe?.(ch.instanceName, "restart", "done");
                     continue;
@@ -14247,7 +14549,7 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
                             lastActivity,
                             currentTask,
                             idle: this.getInstanceIdle(inst.name),
-                            state: this.getInstanceExecutionState(inst.name),
+                            ...this.instancePresentation(inst.name),
                         };
                     });
                     res.setHeader("Access-Control-Allow-Origin", "*");
@@ -14504,6 +14806,7 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
                 backend,
                 effort,
                 effort_source,
+                ...this.instancePresentation(name),
             };
         });
         return {