@songsid/agend 2.1.4-beta.2 → 2.1.4-beta.21

package/dist/fleet-manager.js

@@ -3,12 +3,14 @@ import { randomBytes } from "node:crypto";
 import { createServer } from "node:http";
 import { join, dirname, basename } from "node:path";
 import { fileURLToPath } from "node:url";
+import { isDeepStrictEqual } from "node:util";
 import { getAgendHome, ensureWorkspaceGit } from "./paths.js";
-import { clearUpdateMarker, isUpdateInProgress } from "./update-marker.js";
+import { beginUpdateProgress as persistUpdateProgress, clearUpdateMarker, isUpdateInProgress, readUpdateProgress, setUpdateProgressStage, } from "./update-marker.js";
+import { formatUpdateProgress } from "./update-progress.js";
 import { sdNotify, sdNotifyBlocking } from "./sd-notify.js";
 import { readFleetMemory } from "./process-memory.js";
 import { ReplyDeduper } from "./reply-dedup.js";
-import { isScalar, parseDocument } from "yaml";
+import { isMap, isScalar, parseDocument } from "yaml";
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 /** Fallback access policy for a channel with no `access:` block — open (no gate). */
@@ -29,7 +31,7 @@ import { processAttachments } from "./channel/attachment-handler.js";
 import { routeToolCall } from "./channel/tool-router.js";
 import { Scheduler } from "./scheduler/index.js";
 import { DEFAULT_SCHEDULER_CONFIG } from "./scheduler/index.js";
-import { TopicCommands, saveCommandForBackend, parseSaveFilename, parsePauseWakeCommand, SAVE_FILENAME_RE, SAVE_UNSUPPORTED_MSG, resolveInstanceContext, forgetInstanceContext } from "./topic-commands.js";
+import { TopicCommands, saveCommandForBackend, parseSaveFilename, parsePauseWakeCommand, SAVE_FILENAME_RE, resolveInstanceContext, forgetInstanceContext } from "./topic-commands.js";
 import { DailySummary } from "./daily-summary.js";
 import { WebhookEmitter } from "./webhook-emitter.js";
 import { TmuxControlClient } from "./tmux-control.js";
@@ -41,9 +43,9 @@ import { StatuslineWatcher } from "./statusline-watcher.js";
 import { outboundHandlers } from "./outbound-handlers.js";
 import { handleWebRequest, broadcastSseEvent } from "./web-api.js";
 import { handleViewRequest, isViewPath } from "./view-api.js";
-import { handleUsageRequest, isUsagePath } from "./usage/usage-api.js";
+import { handleUsageRequest, isUsagePath, usageProviderIdForBackend } from "./usage/usage-api.js";
 import { handleSettingsRequest } from "./settings-api.js";
-import { setLocale, detectLocale, t } from "./locale.js";
+import { setLocale, detectLocale, getLocale, t } from "./locale.js";
 import { handleAgentRequest } from "./agent-endpoint.js";
 import { ClassicChannelManager, getClassicBackendChoices, isSelectableClassicBackend, readClassicLastActivityAt } from "./classic-channel-manager.js";
 import { validateFleetConfig } from "./config-validator.js";
@@ -53,6 +55,8 @@ import { releaseProcessFleetLock } from "./fleet-lock.js";
 import { GENERAL_PAUSE_ERROR, isGeneralInstance } from "./general-instance.js";
 import { loadOrCreateWebToken, WEB_TOKEN_INVALID_MESSAGE } from "./web-auth.js";
 import { RestartProgress } from "./restart-progress.js";
+import { collectRedundantInstanceDefaultPaths } from "./fleet-yaml-slim.js";
+import { canUnlockAdvancedTips, DailyTipScheduler, selectTip } from "./tips.js";
 import { getTmuxSession } from "./config.js";
 export function resolveReplyThreadId(argsThreadId, instanceConfig) {
     if (typeof argsThreadId === "string" && argsThreadId.length > 0) {
@@ -105,6 +109,8 @@ const CANCEL_BTN_IDLE_RETIRE_GRACE_MS = 2_000;
  * button alone (the idle edge retires it when the run really ends).
  */
 const REPLY_RETIRE_GRACE_MS = 2 * 60_000;
+/** Bound for the daemon to capture the pane and answer a post-reply state query. */
+const REPLY_STATE_REFRESH_TIMEOUT_MS = 2_000;
 /**
  * The daemon only broadcasts execution state on TRANSITIONS, so a long
  * single-state run sends nothing for hours. The idle backstop therefore pokes a
@@ -134,6 +140,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
@@ -153,6 +161,36 @@ const PROGRESS_ACTIVITY_MAX_CHARS = 48;
  * 🫡 passes too — it reads as a deliberate acknowledgement, not plumbing.
  */
 const DELIVERY_STATUS_EMOJIS = new Set(["👀", "⏳", "✅", "❌"]);
+/**
+ * Reactions that are neither delivery plumbing nor meaningful conversational
+ * feedback. Keep this separate from DELIVERY_STATUS_EMOJIS so adding a UI-only
+ * emoji never changes the documented delivery-state protocol.
+ */
+const IGNORED_REACTION_EMOJIS = new Set(["📷"]);
+const HOT_INSTANCE_CONFIG_KEYS = new Set([
+    "tool_progress",
+    "mcp_proxy_reply",
+    "auto_pause_after",
+    "warm_cap",
+    "display_name",
+    "description",
+    "tags",
+    "log_level",
+]);
+function splitHotColdConfig(config) {
+    const hot = {};
+    const cold = {};
+    for (const [key, value] of Object.entries(config)) {
+        (HOT_INSTANCE_CONFIG_KEYS.has(key) ? hot : cold)[key] = value;
+    }
+    return { hot, cold };
+}
+function hotConfigUpdate(config) {
+    const update = {};
+    for (const key of HOT_INSTANCE_CONFIG_KEYS)
+        update[key] = config[key] ?? null;
+    return update;
+}
 /**
  * How long a delivery waits out a disconnected instance IPC before giving up.
  *
@@ -166,7 +204,15 @@ const CLASSIC_BACKEND_CALLBACK_PREFIX = "classic-backend:";
 const MODEL_SELECT_CALLBACK_PREFIX = "model-select:";
 const EFFORT_SELECT_CALLBACK_PREFIX = "effort-select:";
 const INTERACTIVE_ASSIST_CALLBACK_PREFIX = "interactive-assist:";
-const INTERACTIVE_ASSIST_TIMEOUT_MS = 15 * 60_000;
+const EXIT_RESTART_CALLBACK_PREFIX = "exit-restart:";
+const HANG_CALLBACK_PREFIX = "hang:";
+const CLEAR_CONFIRM_CALLBACK_PREFIX = "clear-confirm:";
+const TIP_DISMISS_CALLBACK_PREFIX = "tip-dismiss:";
+const TIP_UNLOCK_CALLBACK_PREFIX = "tip-unlock:";
+const CLEAR_CONFIRM_TIMEOUT_MS = 15_000;
+/** Default lifetime for long-lived nonce prompts (clear overrides this to 15s). */
+const NONCE_BUTTON_TIMEOUT_MS = 15 * 60_000;
+const TIP_BUTTON_TIMEOUT_MS = 24 * 60 * 60_000;
 const CLI_ENV_TTL_MS = 24 * 60 * 60 * 1000; // /model reads cached CLI env within 24h
 export class FleetManager {
     dataDir;
@@ -213,6 +259,7 @@ export class FleetManager {
     costGuard = null;
     statuslineWatcher;
     dailySummary = null;
+    dailyTipScheduler = null;
     webhookEmitter = null;
     // Topic icon + auto-archive state
     topicIcons = {};
@@ -225,6 +272,13 @@ export class FleetManager {
     warmCapEvicting = new Set();
     /** Per-instance tail keeps cross-instance and scheduled deliveries FIFO. */
     idleGatedDeliveryTails = new Map();
+    /**
+     * Per-instance cancellation epoch for deliveries which have not reached the
+     * daemon yet. A cancel advances the epoch; queued work captures the old value
+     * and becomes a no-op, while messages arriving after the click capture the new
+     * value and remain deliverable.
+     */
+    deliveryEpochs = new Map();
     /** Non-user work must observe a fresh idle snapshot after the latest delivery. */
     lastDeliveryAt = new Map();
     /** State-cache updates wake event-driven idle waiters without busy polling. */
@@ -241,6 +295,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. */
@@ -255,8 +311,8 @@ export class FleetManager {
     /** In-flight /effort selections, same coordinator shape as pendingModelSelects. */
     pendingEffortSelects = new Map();
     pendingModelSelects = new Map();
-    /** One-shot General assistance buttons for stable interactive terminal prompts. */
-    pendingInteractivePromptAssists = new Map();
+    /** nonce → pending button prompt (hang restart, interactive assist, clean-exit restart). */
+    pendingNonceButtons = new Map();
     // Model failover state
     failoverActive = new Map(); // instance → current failover model
     // IPC reconnect: tracks instances being intentionally stopped (skip reconnect)
@@ -278,6 +334,10 @@ export class FleetManager {
     healthServer = null;
     healthPortRetried = false;
     updateCheckTimer = null;
+    updateProgressTimer = null;
+    updateProgressEditRunning = false;
+    lastUpdateProgressText = null;
+    updateCompletionTipText = null;
     eventLogPruneTimer = null;
     logRotateTimer = null;
     /** Days of event/activity history to keep. */
@@ -326,7 +386,7 @@ export class FleetManager {
             // fleet.yaml, sent SIGHUP, and got no reaction and no explanation.
             this.logger.error({ err }, "SIGHUP config reload failed");
             const message = err instanceof Error ? err.message : String(err);
-            this.notifyFleetError(`⚠️ fleet.yaml reload FAILED — ${message}\nThe previous configuration is still running.`);
+            this.notifyFleetError(t("fleet.reload_failed", message));
         })
             .finally(() => {
             this.reconcileInFlight = null;
@@ -557,6 +617,65 @@ export class FleetManager {
         }
         await data.respond(await this.topicCommands.runPauseWake(target, action));
     }
+    async handleUpdateSlash(data, adapterId) {
+        const allowed = this.fleetConfig?.channel?.access?.allowed_users ?? [];
+        if (allowed.length > 0 && !allowed.some(u => String(u) === String(data.userId))) {
+            await data.respond(t("not_authorized"));
+            return;
+        }
+        const messageId = await data.respond(t("update.progress.preparing", 0));
+        const adapter = this.adapters.get(adapterId) ?? this.adapter;
+        if (messageId && adapter) {
+            const chatId = String(this.getChannelConfig(adapterId)?.group_id ?? data.channelId);
+            this.beginUpdateProgress(adapter, chatId, data.channelId, messageId);
+        }
+        const { spawn } = await import("node:child_process");
+        const currentVersion = JSON.parse(readFileSync(join(dirname(fileURLToPath(import.meta.url)), "..", "package.json"), "utf-8")).version ?? "";
+        const command = currentVersion.includes("beta") ? "agend update --beta" : "agend update";
+        const child = spawn("sh", ["-c", `sleep 2 && ${command}`], { detached: true, stdio: "ignore" });
+        child.once("error", err => this.failUpdateProgress(err.message));
+        child.unref();
+    }
+    async handleTipsSlash(data, adapterId) {
+        if (!this.fleetConfig)
+            return;
+        const mode = typeof data.options?.mode === "string" ? data.options.mode : "";
+        if (mode === "advanced on") {
+            if (!this.isFleetAdmin(data.userId, adapterId)) {
+                await data.respond(t("permission.denied"));
+                return;
+            }
+            await data.respond(this.unlockAdvancedTips(data.userId)
+                ? t("tips.advanced.unlocked")
+                : t("tips.unavailable"));
+            return;
+        }
+        if (mode === "on" || mode === "off") {
+            if (!this.isFleetAdmin(data.userId, adapterId)) {
+                await data.respond(t("permission.denied"));
+                return;
+            }
+            this.fleetConfig.defaults.tips = mode === "on";
+            this.saveFleetConfig();
+            await data.respond(t(mode === "on" ? "tips.enabled" : "tips.disabled"));
+            return;
+        }
+        const route = this.routing.resolve(data.channelId);
+        if (!route || route.kind !== "general") {
+            await data.respond(t("tips.general_only"));
+            return;
+        }
+        const adapter = this.adapters.get(adapterId) ?? this.adapter;
+        if (!adapter) {
+            await data.respond(t("tips.unavailable"));
+            return;
+        }
+        const chatId = this.getGroupIdForInstance(route.name) || data.channelId;
+        const result = await this.promptTip(route.name, adapter, chatId, data.channelId);
+        await data.respond(t(result === "posted"
+            ? "tips.posted"
+            : result === "empty" ? "tips.empty" : "tips.unavailable"));
+    }
     /** Admin-only full conversation reset for fleet-topic and Classic instances. */
     async handleClearSlash(data, adapterId) {
         if (!this.isModelAdmin(data.userId, data.channelId, adapterId)) {
@@ -568,7 +687,14 @@ export class FleetManager {
             await data.respond(t("classic.no_agent"));
             return;
         }
-        await data.respond(await this.topicCommands.sendClear(name));
+        const adapter = this.adapters.get(adapterId) ?? this.adapter;
+        if (!adapter) {
+            await data.respond(t("clear.prompt_unavailable"));
+            return;
+        }
+        const chatId = String(this.getChannelConfig(adapterId)?.group_id ?? data.channelId);
+        const fallback = await this.promptClearConfirmation(name, data.channelId, adapter, chatId, data.channelId);
+        await data.respond(fallback ?? t("clear.confirm_posted"));
     }
     /** Get the adapter bound to an instance, falling back to primary adapter */
     getAdapterForInstance(name) {
@@ -702,6 +828,30 @@ export class FleetManager {
             return null;
         return this.instanceStateCache.get(name)?.state ?? null;
     }
+    /**
+     * Subscription providers currently relevant to this fleet. Stopped/crashed
+     * rows do not keep a usage card alive, while persisted paused instances do.
+     * Classic channels use their effective backend merge chain, not the raw row.
+     */
+    getActiveUsageProviderIds() {
+        const providers = new Set();
+        const add = (name, backend) => {
+            const status = this.getInstanceStatus(name);
+            if (status !== "running" && status !== "paused")
+                return;
+            const provider = usageProviderIdForBackend(backend);
+            if (provider)
+                providers.add(provider);
+        };
+        for (const [name, config] of Object.entries(this.fleetConfig?.instances ?? {})) {
+            // loadFleetConfig() has already merged the fleet default into each row.
+            add(name, config.backend ?? this.fleetConfig?.defaults?.backend ?? "claude-code");
+        }
+        for (const channel of this.classicChannels?.getAll() ?? []) {
+            add(channel.instanceName, this.classicChannels?.getBackendByInstance(channel.instanceName, this.fleetConfig?.defaults?.backend));
+        }
+        return providers;
+    }
     isClassicInstance(name) {
         return this.classicChannels?.getAll().some(channel => channel.instanceName === name) ?? false;
     }
@@ -814,7 +964,7 @@ export class FleetManager {
                 .finally(() => this.warmCapEvicting.delete(victim));
         }
     }
-    waitForInstanceIdle(instanceName, timeoutMs, idleObservedAfter = 0) {
+    waitForInstanceIdle(instanceName, timeoutMs, idleObservedAfter = 0, cancelled) {
         const isReady = () => {
             const snapshot = this.instanceStateCache.get(instanceName);
             return snapshot?.state === "idle"
@@ -836,8 +986,12 @@ export class FleetManager {
                     this.instanceIdleWaiters.delete(instanceName);
                 resolve(idle);
             };
-            const check = () => { if (isReady())
-                finish(true); };
+            const check = () => {
+                if (cancelled?.())
+                    finish(false);
+                else if (isReady())
+                    finish(true);
+            };
             const query = () => {
                 const ipc = this.instanceIpcClients.get(instanceName);
                 if (ipc?.connected) {
@@ -853,22 +1007,74 @@ export class FleetManager {
             query();
         });
     }
-    async deliverWithIdleGate(instanceName, payload, timeoutMs) {
+    /**
+     * Ask the daemon to capture the pane before answering, then wait for any state
+     * report produced after this request. The ordinary query is intentionally
+     * cache-only (idle gates call it frequently); this opt-in refresh is reserved
+     * for lifecycle decisions where a stale state would strand UI.
+     */
+    refreshInstanceExecutionState(instanceName, timeoutMs) {
+        const ipc = this.instanceIpcClients.get(instanceName);
+        if (!ipc?.connected)
+            return Promise.resolve(false);
+        const previous = this.instanceStateCache.get(instanceName);
+        return new Promise(resolve => {
+            let settled = false;
+            const finish = (refreshed) => {
+                if (settled)
+                    return;
+                settled = true;
+                clearTimeout(timeout);
+                const waiters = this.instanceIdleWaiters.get(instanceName);
+                waiters?.delete(check);
+                if (waiters?.size === 0)
+                    this.instanceIdleWaiters.delete(instanceName);
+                resolve(refreshed);
+            };
+            const check = () => {
+                if (this.instanceStateCache.get(instanceName) !== previous)
+                    finish(true);
+            };
+            const waiters = this.instanceIdleWaiters.get(instanceName) ?? new Set();
+            waiters.add(check);
+            this.instanceIdleWaiters.set(instanceName, waiters);
+            const timeout = setTimeout(() => finish(false), timeoutMs);
+            timeout.unref?.();
+            const sent = ipc.send({
+                type: "query_instance_state",
+                requestId: `reply-grace-${Date.now()}`,
+                refresh: true,
+            });
+            if (!sent)
+                finish(false);
+        });
+    }
+    async deliverWithIdleGate(instanceName, payload, timeoutMs, deliveryEpoch) {
+        if (!this.isDeliveryEpochCurrent(instanceName, deliveryEpoch))
+            return;
         let idleObservedAfter = this.lastDeliveryAt.get(instanceName) ?? 0;
         if (this.lifecycle.isPaused(instanceName)) {
             const wakeStartedAt = Date.now();
             await this.lifecycle.wake(instanceName, 30_000);
+            if (!this.isDeliveryEpochCurrent(instanceName, deliveryEpoch))
+                return;
             // Waking added one to the warm count — make room by evicting a different
             // LRU idle instance (never this one; it's about to work).
             this.enforceWarmCap(instanceName);
             // Never satisfy a post-wake gate from a stale pre-pause cache entry.
             idleObservedAfter = Math.max(idleObservedAfter, wakeStartedAt);
         }
-        const idle = await this.waitForInstanceIdle(instanceName, timeoutMs, idleObservedAfter);
+        const idle = await this.waitForInstanceIdle(instanceName, timeoutMs, idleObservedAfter, () => !this.isDeliveryEpochCurrent(instanceName, deliveryEpoch));
+        if (!this.isDeliveryEpochCurrent(instanceName, deliveryEpoch)) {
+            this.logger.info({ instanceName }, "Pending delivery dropped by user cancel");
+            return;
+        }
         if (!idle) {
             this.logger.warn({ instanceName, timeoutMs }, "Idle gate timed out; forcing delivery");
         }
-        await this.sendWhenConnected(instanceName, payload);
+        await this.sendWhenConnected(instanceName, payload, deliveryEpoch);
+        if (!this.isDeliveryEpochCurrent(instanceName, deliveryEpoch))
+            return;
         this.lastDeliveryAt.set(instanceName, Date.now());
     }
     /**
@@ -887,7 +1093,9 @@ export class FleetManager {
      * instance, *including* when the socket happens to be up: otherwise a message
      * arriving after the reconnect could overtake one that has been waiting for it.
      */
-    async sendWhenConnected(instanceName, payload) {
+    async sendWhenConnected(instanceName, payload, deliveryEpoch = this.getDeliveryEpoch(instanceName)) {
+        if (!this.isDeliveryEpochCurrent(instanceName, deliveryEpoch))
+            return;
         const queued = this.ipcWaitTails.get(instanceName);
         if (!queued) {
             const ipc = this.instanceIpcClients.get(instanceName);
@@ -896,7 +1104,11 @@ export class FleetManager {
         }
         const attempt = (queued ?? Promise.resolve())
             .catch(() => { })
-            .then(() => this.sendAfterIpcReturns(instanceName, payload));
+            .then(() => {
+            if (!this.isDeliveryEpochCurrent(instanceName, deliveryEpoch))
+                return;
+            return this.sendAfterIpcReturns(instanceName, payload, deliveryEpoch);
+        });
         // The chain stores a settled-either-way promise so one failed delivery cannot
         // wedge every later one, and so `queued` above is safe to await unguarded.
         const tail = attempt.catch(() => { });
@@ -913,10 +1125,12 @@ export class FleetManager {
         }
     }
     /** Poll for the instance's IPC to come back, then send. Throws if it does not. */
-    async sendAfterIpcReturns(instanceName, payload) {
+    async sendAfterIpcReturns(instanceName, payload, deliveryEpoch = this.getDeliveryEpoch(instanceName)) {
         const deadline = Date.now() + IPC_RECONNECT_GRACE_MS;
         let warned = false;
         for (;;) {
+            if (!this.isDeliveryEpochCurrent(instanceName, deliveryEpoch))
+                return;
             // Re-read every round: a reconnect replaces the IpcClient object entirely,
             // so a cached reference would stay dead forever.
             const ipc = this.instanceIpcClients.get(instanceName);
@@ -934,6 +1148,8 @@ export class FleetManager {
     }
     /** Single delivery facade: wake paused CLIs and serialize non-user work behind idle. */
     async deliverToInstance(instanceName, payload, options = {}) {
+        const deliveryEpoch = this.getDeliveryEpoch(instanceName);
+        const deliveryPayload = { ...payload, delivery_epoch: deliveryEpoch };
         const meta = payload.meta && typeof payload.meta === "object"
             ? payload.meta
             : undefined;
@@ -945,16 +1161,20 @@ export class FleetManager {
         if (!waitForIdle) {
             if (this.lifecycle.isPaused(instanceName)) {
                 await this.lifecycle.wake(instanceName, 30_000);
+                if (!this.isDeliveryEpochCurrent(instanceName, deliveryEpoch))
+                    return;
                 this.enforceWarmCap(instanceName); // woke one → evict a different LRU idle if over cap
             }
-            await this.sendWhenConnected(instanceName, payload);
+            await this.sendWhenConnected(instanceName, deliveryPayload, deliveryEpoch);
+            if (!this.isDeliveryEpochCurrent(instanceName, deliveryEpoch))
+                return;
             // A cross-instance item arriving before the daemon observes this turn as
             // working must not trust the stale idle snapshot from before the send.
             this.lastDeliveryAt.set(instanceName, Date.now());
             return;
         }
         const previous = this.idleGatedDeliveryTails.get(instanceName) ?? Promise.resolve();
-        const delivery = previous.catch(() => { }).then(() => this.deliverWithIdleGate(instanceName, payload, options.idleTimeoutMs ?? 60_000));
+        const delivery = previous.catch(() => { }).then(() => this.deliverWithIdleGate(instanceName, deliveryPayload, options.idleTimeoutMs ?? 60_000, deliveryEpoch));
         this.idleGatedDeliveryTails.set(instanceName, delivery);
         try {
             await delivery;
@@ -1033,19 +1253,34 @@ export class FleetManager {
             this.logger.info({ name }, "Instance already running, skipping");
             return;
         }
+        const backend = config.backend ?? this.fleetConfig?.defaults?.backend ?? "claude-code";
         if (config.general_topic) {
             // antigravity (agy) does not read MCP instructions — fleet context and
             // routing instructions are not injected, so it cannot act as a dispatcher.
-            const backend = config.backend ?? this.fleetConfig?.defaults?.backend ?? "claude-code";
             if (backend === "antigravity") {
                 this.logger.warn({ name }, "antigravity backend does not support MCP instructions — general dispatcher will not work correctly");
-                this.notifyInstanceTopic(name, "⚠️ antigravity backend is not supported for General instances (no MCP instructions injection). Switch to claude-code or kiro-cli.");
+                this.notifyInstanceTopic(name, t("general.antigravity_unsupported"));
+            }
+            this.ensureGeneralInstructions(config.working_directory, backend, name);
+        }
+        else if (kind === "fleet-topic") {
+            // Workers get only role-eligible on-demand skills. Classic instances are
+            // deliberately excluded: their workspace and conversation lifecycle are
+            // managed independently from fleet-topic workers.
+            try {
+                const skillsWorkDir = this.resolveKnowledgeWorkDir(config.working_directory, backend, name);
+                this.syncRoleSkills(skillsWorkDir, backend, "worker");
+            }
+            catch (err) {
+                // Skill publishing is additive. A read-only or temporarily unavailable
+                // workspace must not turn an otherwise valid worker startup into a
+                // fleet outage.
+                this.logger.warn({ err, name, backend }, "Failed to sync worker skills — continuing startup");
             }
-            this.ensureGeneralInstructions(config.working_directory, config.backend);
         }
         await this.lifecycle.start(name, config, topicMode, {
             kind,
-            backend: config.backend ?? this.fleetConfig?.defaults?.backend ?? "claude-code",
+            backend,
             model: this.resolveInstanceModel(name).display,
         });
         // Only clear a stale process status after a real start succeeded.  Clearing
@@ -1210,7 +1445,18 @@ export class FleetManager {
         this.instanceStateCache.delete(name);
         this.instanceProcessStatus.delete(name);
         this.lastDeliveryAt.delete(name);
-        return this.lifecycle.stop(name);
+        // A pending hang/exit/assist offer refers to the instance being torn down;
+        // left alone it would stay clickable for the rest of its 15 minutes. Clear
+        // again AFTER the stop completes: the teardown itself can emit hang /
+        // interactive-prompt / clean-exit events whose handlers post fresh prompts
+        // while the stop is still awaiting (the TOCTOU sol's review called out).
+        this.clearNoncePromptsForInstance(name);
+        try {
+            return await this.lifecycle.stop(name);
+        }
+        finally {
+            this.clearNoncePromptsForInstance(name);
+        }
     }
     /** Restart a single instance, reloading fleet.yaml first to pick up config changes. */
     async restartSingleInstance(name, opts) {
@@ -1310,6 +1556,76 @@ export class FleetManager {
     getDashboardAccess() {
         return { ready: this.healthServerListening, token: this.webToken };
     }
+    beginUpdateProgress(adapter, chatId, threadId, messageId) {
+        persistUpdateProgress(this.dataDir, {
+            adapterId: adapter.id,
+            chatId,
+            ...(threadId ? { threadId } : {}),
+            messageId,
+        });
+        this.lastUpdateProgressText = null;
+        this.updateCompletionTipText = null;
+        this.startUpdateProgressMonitor(adapter);
+    }
+    failUpdateProgress(message) {
+        setUpdateProgressStage(this.dataDir, "failed", { error: message });
+    }
+    /** The old fleet edits CLI install stages; the new fleet adopts the same message below. */
+    startUpdateProgressMonitor(initialAdapter) {
+        if (this.updateProgressTimer)
+            clearInterval(this.updateProgressTimer);
+        const tick = async () => {
+            if (this.updateProgressEditRunning)
+                return;
+            const marker = readUpdateProgress(this.dataDir);
+            if (!marker) {
+                if (this.updateProgressTimer)
+                    clearInterval(this.updateProgressTimer);
+                this.updateProgressTimer = null;
+                return;
+            }
+            const target = marker.progress.target;
+            const adapter = this.adapters.get(target.adapterId) ?? (initialAdapter?.id === target.adapterId ? initialAdapter : undefined);
+            if (!adapter)
+                return;
+            let text = formatUpdateProgress(marker);
+            // No-restart updates complete in the old fleet process, so they never
+            // reach RestartProgress.finish(). Append the same optional tip here.
+            if (marker.progress.stage === "complete" && this.tipsEnabled()) {
+                if (this.updateCompletionTipText === null) {
+                    const tip = this.pickAvailableTip();
+                    this.updateCompletionTipText = tip ? this.formatTip(tip) : "";
+                }
+                if (this.updateCompletionTipText)
+                    text += `\n\n${this.updateCompletionTipText}`;
+            }
+            if (text === this.lastUpdateProgressText)
+                return;
+            this.updateProgressEditRunning = true;
+            try {
+                await adapter.editMessage(target.chatId, target.messageId, text, target.threadId);
+                this.lastUpdateProgressText = text;
+                if (marker.progress.stage === "failed" || marker.progress.stage === "complete") {
+                    clearUpdateMarker(this.dataDir);
+                    if (this.updateProgressTimer)
+                        clearInterval(this.updateProgressTimer);
+                    this.updateProgressTimer = null;
+                }
+            }
+            catch (err) {
+                this.logger.warn({ err }, "Failed to edit update progress");
+            }
+            finally {
+                this.updateProgressEditRunning = false;
+            }
+        };
+        void tick();
+        // Poll stages faster than the elapsed-time display. npm verification and
+        // service-file refresh can be short; 200ms prevents those stages from being
+        // skipped while the text cache still limits normal edits to once per second.
+        this.updateProgressTimer = setInterval(() => void tick(), 200);
+        this.updateProgressTimer.unref?.();
+    }
     /** Start all instances from fleet config */
     async startAll(configPath) {
         const startupStartedAt = Date.now();
@@ -1323,7 +1639,17 @@ export class FleetManager {
         // Rotate fleet.log if oversized (before any logging)
         rotateLogIfNeeded(join(this.dataDir, "fleet.log"));
         const fleet = this.loadConfig(configPath);
+        this.slimFleetConfigAtStartup();
         setLocale(detectLocale(fleet)); // user-facing text language (fleet.yaml defaults.locale / timezone)
+        const savedUpdateProgress = readUpdateProgress(this.dataDir);
+        const pendingUpdateProgress = savedUpdateProgress
+            && savedUpdateProgress.progress.stage !== "failed"
+            && savedUpdateProgress.progress.stage !== "complete"
+            ? savedUpdateProgress
+            : null;
+        if (pendingUpdateProgress) {
+            setUpdateProgressStage(this.dataDir, "starting", { version: pendingUpdateProgress.progress.version });
+        }
         this.initializeWebAuthTokens();
         const topicMode = fleet.channel?.mode === "topic" || !!fleet.channels?.some(ch => ch.mode === "topic");
         // Set tmux socket isolation for custom AGEND_HOME
@@ -1371,9 +1697,8 @@ export class FleetManager {
         // routing does NOT go through the routing engine (single-key, can't hold two
         // bots in one channel) — it resolves per-bot via getInstanceByChannel.
         this.classicChannels = new ClassicChannelManager(this.dataDir, this.logger);
-        const primaryCh = fleet.channels?.[0] ?? fleet.channel;
-        if (primaryCh)
-            this.classicChannels.setPrimaryAdapterId(primaryCh.id ?? primaryCh.type);
+        const classicAdapters = fleet.channels?.length ? fleet.channels : (fleet.channel ? [fleet.channel] : []);
+        this.classicChannels.configureAdapters(classicAdapters);
         // Restore the persisted bot binding so replies/cancel go through the right
         // bot after a restart (before this, inbound would re-bind lazily).
         for (const ch of this.classicChannels.getAll()) {
@@ -1542,7 +1867,7 @@ export class FleetManager {
             const generalDir = join(getAgendHome(), name);
             mkdirSync(generalDir, { recursive: true });
             const backendName = fleet.defaults.backend ?? "claude-code";
-            this.ensureGeneralInstructions(generalDir, backendName);
+            this.ensureGeneralInstructions(generalDir, backendName, name);
             fleet.instances[name] = {
                 ...DEFAULT_INSTANCE_CONFIG,
                 working_directory: generalDir,
@@ -1561,6 +1886,13 @@ export class FleetManager {
             this.scheduler = new Scheduler(join(this.dataDir, "scheduler.db"), (schedule) => this.handleScheduleTrigger(schedule), schedulerConfig, (name) => this.fleetConfig?.instances?.[name] != null || !!this.classicChannels?.getAll().some(ch => ch.instanceName === name));
             this.scheduler.init();
             this.logger.info("Scheduler initialized");
+            // Tips share the daily-report clock but remain an independent internal
+            // job: disabling daily_summary must not disable tips (and vice versa).
+            // The callback checks defaults.tips at fire time, so /tips on|off is hot.
+            this.dailyTipScheduler = new DailyTipScheduler(summaryConfig, costGuardConfig.timezone, () => this.sendTipToGeneral().catch(err => {
+                this.logger.warn({ err }, "Failed to send daily tip");
+            }));
+            this.dailyTipScheduler.start();
             // Inject active decisions as env var for MCP instructions.
             // Snapshotted at startup — new decisions via post_decision are available
             // through list_decisions tool but not auto-injected until restart.
@@ -1580,7 +1912,7 @@ export class FleetManager {
         const allEntries = Object.entries(fleet.instances);
         const generals = allEntries.filter(([_, cfg]) => cfg.general_topic);
         const others = allEntries.filter(([_, cfg]) => !cfg.general_topic);
-        const startupProgress = new RestartProgress(this.runnableStartupCount(fleet, topicMode), startupStartedAt, this.logger);
+        const startupProgress = new RestartProgress(this.runnableStartupCount(fleet, topicMode), pendingUpdateProgress?.startedAt ?? startupStartedAt, this.logger, { mode: pendingUpdateProgress ? "update" : "restart" });
         if (generals.length > 0) {
             for (const [name, cfg] of generals) {
                 try {
@@ -1619,7 +1951,19 @@ export class FleetManager {
                     this.logger.error({ err }, "startSharedAdapter failed — fleet continues without some adapters");
                 }
             })();
-            progressStart = adapterStartup.then(() => startupProgress.start(this.restartProgressTarget()));
+            progressStart = adapterStartup.then(() => {
+                if (pendingUpdateProgress) {
+                    const saved = pendingUpdateProgress.progress.target;
+                    const adapter = this.adapters.get(saved.adapterId);
+                    const target = adapter ? {
+                        adapter,
+                        chatId: saved.chatId,
+                        threadId: saved.threadId,
+                    } : null;
+                    return startupProgress.resume(target, saved.messageId);
+                }
+                return startupProgress.start(this.restartProgressTarget());
+            });
         }
         // The systemd watchdog answers exactly one question: is this process still
         // turning its event loop? Pinging from a timer proves that, and after the
@@ -1731,6 +2075,12 @@ export class FleetManager {
                 version: agendVersion,
                 pausedNames,
                 failedNames,
+                tipText: pendingUpdateProgress && this.tipsEnabled()
+                    ? (() => {
+                        const tip = this.pickAvailableTip();
+                        return tip ? this.formatTip(tip) : undefined;
+                    })()
+                    : undefined,
             });
             if (!progressCompleted && this.adapter && fleet.channel?.group_id) {
                 let text;
@@ -1892,14 +2242,14 @@ export class FleetManager {
     notifyAdapterFailure(adapterId, error) {
         const generalId = this.findGeneralInstance();
         if (generalId) {
-            this.notifyInstanceTopic(generalId, `⚠️ Adapter "${adapterId}" failed to start: ${error}\nRetrying in background. Other adapters unaffected.`);
+            this.notifyInstanceTopic(generalId, t("adapter.start_failed", adapterId, error));
         }
     }
     /** Notify admin that a retried adapter reconnected. */
     notifyAdapterRecovery(adapterId, attempts) {
         const generalId = this.findGeneralInstance();
         if (generalId) {
-            this.notifyInstanceTopic(generalId, `✅ Adapter "${adapterId}" reconnected (after ${attempts} ${attempts === 1 ? "retry" : "retries"}).`);
+            this.notifyInstanceTopic(generalId, t("adapter.reconnected", adapterId, attempts));
         }
     }
     /** Get adapter states for /status visibility. */
@@ -1997,7 +2347,15 @@ export class FleetManager {
             await this.handleInboundReaction(r);
         }, this.logger, "adapter.reaction"));
         this.adapter.on("callback_query", safeHandler(async (data) => {
-            if (await this.handleInteractivePromptAssist(data, adapterId))
+            if (await this.handleTipDismiss(data, adapterId, this.adapter ?? undefined))
+                return;
+            if (await this.handleTipUnlock(data, adapterId, this.adapter ?? undefined))
+                return;
+            if (await this.handleClearConfirmation(data, adapterId, this.adapter ?? undefined))
+                return;
+            if (await this.handleExitRestartPrompt(data, adapterId, this.adapter ?? undefined))
+                return;
+            if (await this.handleInteractivePromptAssist(data, adapterId, this.adapter ?? undefined))
                 return;
             if (await this.handleClassicBackendSelection(data))
                 return;
@@ -2005,25 +2363,8 @@ export class FleetManager {
                 return;
             if (await this.handleEffortSelection(data))
                 return;
-            if (data.callbackData.startsWith("hang:")) {
-                const parts = data.callbackData.split(":");
-                const action = parts[1];
-                const instanceName = parts[2];
-                if (action === "restart") {
-                    await this.stopInstance(instanceName);
-                    const config = this.fleetConfig?.instances[instanceName];
-                    if (config) {
-                        const topicMode = this.fleetConfig?.channel?.mode === "topic";
-                        await this.startInstance(instanceName, config, topicMode);
-                        // startInstance already calls connectIpcToInstance
-                    }
-                    this.adapter?.editMessage(data.chatId, data.messageId, `🔄 ${instanceName} restarted.`, data.threadId).catch(() => { });
-                }
-                else {
-                    this.adapter?.editMessage(data.chatId, data.messageId, `⏳ Continuing to wait for ${instanceName}.`, data.threadId).catch(() => { });
-                }
+            if (await this.handleHangPrompt(data, adapterId, this.adapter ?? undefined))
                 return;
-            }
             if (data.callbackData.startsWith("cancel:")) {
                 this.handleCancelClick(data.callbackData.slice("cancel:".length), this.adapter, data);
                 return;
@@ -2102,6 +2443,43 @@ 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 === "btw") {
+                const name = this.resolveSlashTarget(data.channelId, adapterId);
+                if (!name) {
+                    await data.respond(t("classic.no_agent"));
+                    return;
+                }
+                const btwText = String(data.options?.message ?? "").trim();
+                if (!btwText) {
+                    await data.respond(t("btw.usage"));
+                    return;
+                }
+                const result = this.topicCommands.sendBtw(name, btwText, {
+                    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);
             }
@@ -2157,17 +2535,7 @@ export class FleetManager {
                     : t("collab.off.classic"));
             }
             else if (data.command === "update") {
-                const allowed = this.fleetConfig?.channel?.access?.allowed_users ?? [];
-                if (allowed.length > 0 && !allowed.some(u => String(u) === String(data.userId))) {
-                    await data.respond(t("not_authorized"));
-                    return;
-                }
-                await data.respond(t("update.running"));
-                const { spawn } = await import("node:child_process");
-                const _cv = JSON.parse(readFileSync(join(dirname(fileURLToPath(import.meta.url)), "..", "package.json"), "utf-8")).version ?? "";
-                const _cmd = _cv.includes("beta") ? "agend update --beta" : "agend update";
-                const child = spawn("sh", ["-c", `sleep 2 && ${_cmd}`], { detached: true, stdio: "ignore" });
-                child.unref();
+                await this.handleUpdateSlash(data, adapterId);
             }
             else if (data.command === "doctor") {
                 const allowed = this.fleetConfig?.channel?.access?.allowed_users ?? [];
@@ -2185,12 +2553,15 @@ export class FleetManager {
                     const { getUsageSnapshot } = await import("./usage/usage-api.js");
                     const { renderUsageMarkdown } = await import("./usage/format-rich.js");
                     // slash_command is Discord-only; editReply renders Markdown natively.
-                    await data.respond(renderUsageMarkdown(await getUsageSnapshot()));
+                    await data.respond(renderUsageMarkdown(await getUsageSnapshot(false, this.getActiveUsageProviderIds())));
                 }
                 catch (err) {
-                    await data.respond(`⚠️ Usage fetch failed: ${err.message}`);
+                    await data.respond(t("usage.failed", err.message));
                 }
             }
+            else if (data.command === "tips") {
+                await this.handleTipsSlash(data, adapterId);
+            }
             else if (data.command === "status") {
                 // Admin-gated (like the topic path): the merged table shows every
                 // instance's cost and IPC health.
@@ -2236,6 +2607,43 @@ 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 === "btw") {
+                const name = this.resolveSlashTarget(data.channelId, adapterId);
+                if (!name) {
+                    await data.respond(t("classic.no_agent"));
+                    return;
+                }
+                const btwText = String(data.options?.message ?? "").trim();
+                if (!btwText) {
+                    await data.respond(t("btw.usage"));
+                    return;
+                }
+                const result = this.topicCommands.sendBtw(name, btwText, {
+                    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.
@@ -2312,7 +2720,15 @@ export class FleetManager {
             await this.handleInboundReaction(r);
         }, this.logger, `adapter[${adapterId}].reaction`));
         adapter.on("callback_query", safeHandler(async (data) => {
-            if (await this.handleInteractivePromptAssist(data, adapterId))
+            if (await this.handleTipDismiss(data, adapterId, adapter))
+                return;
+            if (await this.handleTipUnlock(data, adapterId, adapter))
+                return;
+            if (await this.handleClearConfirmation(data, adapterId, adapter))
+                return;
+            if (await this.handleExitRestartPrompt(data, adapterId, adapter))
+                return;
+            if (await this.handleInteractivePromptAssist(data, adapterId, adapter))
                 return;
             if (await this.handleClassicBackendSelection(data))
                 return;
@@ -2320,24 +2736,8 @@ export class FleetManager {
                 return;
             if (await this.handleEffortSelection(data))
                 return;
-            if (data.callbackData.startsWith("hang:")) {
-                const parts = data.callbackData.split(":");
-                const action = parts[1];
-                const instanceName = parts[2];
-                if (action === "restart") {
-                    await this.stopInstance(instanceName);
-                    const config = this.fleetConfig?.instances[instanceName];
-                    if (config) {
-                        const topicMode = this.fleetConfig?.channel?.mode === "topic";
-                        await this.startInstance(instanceName, config, topicMode);
-                    }
-                    adapter.editMessage(data.chatId, data.messageId, `🔄 ${instanceName} restarted.`, data.threadId).catch(() => { });
-                }
-                else {
-                    adapter.editMessage(data.chatId, data.messageId, `⏳ Continuing to wait for ${instanceName}.`, data.threadId).catch(() => { });
-                }
+            if (await this.handleHangPrompt(data, adapterId, adapter))
                 return;
-            }
             if (data.callbackData.startsWith("cancel:")) {
                 this.handleCancelClick(data.callbackData.slice("cancel:".length), adapter, data);
                 return;
@@ -2461,17 +2861,7 @@ export class FleetManager {
                     : t("collab.off.classic"));
             }
             else if (data.command === "update") {
-                const allowed = this.fleetConfig?.channel?.access?.allowed_users ?? [];
-                if (allowed.length > 0 && !allowed.some(u => String(u) === String(data.userId))) {
-                    await data.respond(t("not_authorized"));
-                    return;
-                }
-                await data.respond(t("update.running"));
-                const { spawn } = await import("node:child_process");
-                const _cv = JSON.parse(readFileSync(join(dirname(fileURLToPath(import.meta.url)), "..", "package.json"), "utf-8")).version ?? "";
-                const _cmd = _cv.includes("beta") ? "agend update --beta" : "agend update";
-                const child = spawn("sh", ["-c", `sleep 2 && ${_cmd}`], { detached: true, stdio: "ignore" });
-                child.unref();
+                await this.handleUpdateSlash(data, adapterId);
             }
             else if (data.command === "doctor") {
                 const allowed = this.fleetConfig?.channel?.access?.allowed_users ?? [];
@@ -2489,12 +2879,15 @@ export class FleetManager {
                     const { getUsageSnapshot } = await import("./usage/usage-api.js");
                     const { renderUsageMarkdown } = await import("./usage/format-rich.js");
                     // slash_command is Discord-only; editReply renders Markdown natively.
-                    await data.respond(renderUsageMarkdown(await getUsageSnapshot()));
+                    await data.respond(renderUsageMarkdown(await getUsageSnapshot(false, this.getActiveUsageProviderIds())));
                 }
                 catch (err) {
-                    await data.respond(`⚠️ Usage fetch failed: ${err.message}`);
+                    await data.respond(t("usage.failed", err.message));
                 }
             }
+            else if (data.command === "tips") {
+                await this.handleTipsSlash(data, adapterId);
+            }
             else if (data.command === "status") {
                 // Admin-gated (like the topic path): the merged table shows every
                 // instance's cost and IPC health.
@@ -2540,6 +2933,43 @@ 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 === "btw") {
+                const name = this.resolveSlashTarget(data.channelId, adapterId);
+                if (!name) {
+                    await data.respond(t("classic.no_agent"));
+                    return;
+                }
+                const btwText = String(data.options?.message ?? "").trim();
+                if (!btwText) {
+                    await data.respond(t("btw.usage"));
+                    return;
+                }
+                const result = this.topicCommands.sendBtw(name, btwText, {
+                    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) {
@@ -2657,6 +3087,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") {
@@ -2845,6 +3278,10 @@ export class FleetManager {
             this.logger.debug({ emoji: r.emoji, user: r.username }, "Ignoring delivery-status emoji as a reaction");
             return;
         }
+        if (IGNORED_REACTION_EMOJIS.has(r.emoji)) {
+            this.logger.debug({ emoji: r.emoji, user: r.username }, "Ignoring non-contextual emoji reaction");
+            return;
+        }
         this.eventLog?.logActivity("reaction", r.username, `${r.emoji} ${r.action}`, instanceName);
         if (r.action === "add") {
             this.eventLog?.addReaction(instanceName, r.messageId, r.username, r.emoji);
@@ -3100,6 +3537,42 @@ 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;
+                }
+                // /btw — Claude Code's native side-thread command. Like /steer it is
+                // not admin-gated, but it remains a distinct raw CLI command so Claude
+                // does not fold the question into the active task.
+                if (text === "/btw" || text.startsWith("/btw ") || text.startsWith("/btw@")) {
+                    const btwName = this.classicChannels.getInstanceByChannel(chatId, msg.adapterId);
+                    if (!btwName) {
+                        await msgAdapter?.sendText(chatId, t("classic.no_agent_start"));
+                        return;
+                    }
+                    const btwContent = text.replace(/^\/btw(@\S+)?/, "").trim();
+                    if (!btwContent) {
+                        await msgAdapter?.sendText(chatId, t("btw.usage"));
+                        return;
+                    }
+                    const result = this.topicCommands.sendBtw(btwName, btwContent, 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@")) {
@@ -3112,7 +3585,11 @@ export class FleetManager {
                         await msgAdapter?.sendText(chatId, t("classic.no_agent_start"));
                         return;
                     }
-                    await msgAdapter?.sendText(chatId, await this.topicCommands.sendClear(clearName));
+                    if (!msgAdapter)
+                        return;
+                    const fallback = await this.promptClearConfirmation(clearName, chatId, msgAdapter, chatId);
+                    if (fallback)
+                        await msgAdapter.sendText(chatId, fallback);
                     return;
                 }
                 // Handle /cancel command
@@ -3123,7 +3600,7 @@ export class FleetManager {
                         return;
                     }
                     const ok = this.cancelInstance(cancelName);
-                    await msgAdapter?.sendText(chatId, ok ? `🛑 已送出取消給 ${cancelName}。` : `❌ ${cancelName} 未在執行。`);
+                    await msgAdapter?.sendText(chatId, ok ? t("cancel.sent", cancelName) : t("cancel.not_running", cancelName));
                     return;
                 }
                 // Handle /ctx command
@@ -3160,7 +3637,7 @@ export class FleetManager {
                     const backend = this.classicChannels.getBackendByInstance(saveName, this.fleetConfig?.defaults?.backend);
                     const cmd = saveCommandForBackend(backend, filename);
                     if (!cmd) {
-                        await msgAdapter?.sendText(chatId, SAVE_UNSUPPORTED_MSG);
+                        await msgAdapter?.sendText(chatId, t("save.unsupported"));
                         return;
                     }
                     this.pasteRawToClassicInstance(saveName, cmd);
@@ -3378,10 +3855,10 @@ export class FleetManager {
             return;
         let warning = "";
         if (rl.five_hour_pct >= 95) {
-            warning = `⚠️ ${instanceName} at ${Math.round(rl.five_hour_pct)}% of 5h rate limit. Responses may be slower.`;
+            warning = t("rate_limit.five_hour", instanceName, Math.round(rl.five_hour_pct));
         }
         else if (rl.seven_day_pct >= 95) {
-            warning = `⚠️ ${instanceName} at ${Math.round(rl.seven_day_pct)}% weekly usage. Responses may be slower or fail.`;
+            warning = t("rate_limit.weekly", instanceName, Math.round(rl.seven_day_pct));
         }
         if (!warning)
             return;
@@ -3505,7 +3982,7 @@ export class FleetManager {
             this.clearCancelButton(instanceName);
         }
         else {
-            void this.sendCancelButton(instanceName).then(() => this.armReplyGrace(instanceName));
+            void this.sendCancelButton(instanceName, undefined, true).then(() => this.armReplyGrace(instanceName));
         }
         this.reactDone(instanceName);
         const replyTo = this.lastInboundUser.get(instanceName) ?? "user";
@@ -3542,7 +4019,11 @@ export class FleetManager {
         if (silent) {
             const ipc = this.instanceIpcClients.get(target);
             if (ipc) {
-                ipc.send({ type: "raw_paste", content: message });
+                ipc.send({
+                    type: "raw_paste",
+                    content: message,
+                    delivery_epoch: this.getDeliveryEpoch(target),
+                });
                 this.scheduler.recordRun(id, "delivered");
                 this.logger.info({ target, scheduleId: id, label }, "Silent schedule injected via raw_paste");
             }
@@ -3557,10 +4038,19 @@ export class FleetManager {
         const retryInterval = schedulerDefaults?.retry_interval_ms ?? 30_000;
         const deliver = async () => {
             try {
+                // A schedule has no live inbound adapter context. Seed the daemon with
+                // the target instance's configured world so replies use its persona
+                // after a fresh start instead of falling back to channels[0].
+                const adapterId = this.getInstanceAdapterId(target);
                 await this.deliverToInstance(target, {
                     type: "fleet_schedule_trigger",
                     payload: { schedule_id: id, message: `[Scheduled] ${message}`, label },
-                    meta: { chat_id: reply_chat_id, thread_id: reply_thread_id, user: "scheduler" },
+                    meta: {
+                        chat_id: reply_chat_id,
+                        thread_id: reply_thread_id,
+                        user: "scheduler",
+                        ...(adapterId ? { adapter_id: adapterId } : {}),
+                    },
                 }, { waitForIdle: true });
                 // A scheduled trigger also puts the instance to work — show a cancel button.
                 void this.sendCancelButton(target);
@@ -3708,7 +4198,29 @@ export class FleetManager {
     }
     /** Resolve display name for an instance, fallback to instance name. */
     resolveDisplayName(instanceName) {
-        return this.fleetConfig?.instances[instanceName]?.display_name ?? instanceName;
+        return this.fleetConfig?.instances[instanceName]?.display_name
+            ?? this.classicChannels?.getAll().find(ch => ch.instanceName === instanceName)?.displayName
+            ?? instanceName;
+    }
+    /** Persist identity to the instance's actual config store. Classic instances
+     * are registry rows in classicBot.yaml, not fleet.yaml instance entries. */
+    setInstanceDisplayName(instanceName, displayName) {
+        const fleetInstance = this.fleetConfig?.instances[instanceName];
+        if (fleetInstance) {
+            fleetInstance.display_name = displayName;
+            this.saveFleetConfig();
+            return true;
+        }
+        return this.classicChannels?.setDisplayNameByInstance(instanceName, displayName) ?? false;
+    }
+    setInstanceDescription(instanceName, description) {
+        const fleetInstance = this.fleetConfig?.instances[instanceName];
+        if (fleetInstance) {
+            fleetInstance.description = description;
+            this.saveFleetConfig();
+            return true;
+        }
+        return this.classicChannels?.setDescriptionByInstance(instanceName, description) ?? false;
     }
     handleSetDisplayName(instanceName, msg) {
         const fleetRequestId = msg.fleetRequestId;
@@ -3721,8 +4233,10 @@ export class FleetManager {
             ipc.send({ type: "fleet_display_name_response", fleetRequestId, error: "Name must be 1-30 characters" });
             return;
         }
-        this.fleetConfig.instances[instanceName].display_name = displayName;
-        this.saveFleetConfig();
+        if (!this.setInstanceDisplayName(instanceName, displayName)) {
+            ipc.send({ type: "fleet_display_name_response", fleetRequestId, error: `Instance '${instanceName}' not found` });
+            return;
+        }
         this.logger.info({ instanceName, displayName }, "Display name set");
         ipc.send({ type: "fleet_display_name_response", fleetRequestId, result: { display_name: displayName } });
     }
@@ -3737,8 +4251,10 @@ export class FleetManager {
             ipc.send({ type: "fleet_description_response", fleetRequestId, error: "Description cannot be empty" });
             return;
         }
-        this.fleetConfig.instances[instanceName].description = description;
-        this.saveFleetConfig();
+        if (!this.setInstanceDescription(instanceName, description)) {
+            ipc.send({ type: "fleet_description_response", fleetRequestId, error: `Instance '${instanceName}' not found` });
+            return;
+        }
         this.logger.info({ instanceName, description: description.slice(0, 80) }, "Description set");
         ipc.send({ type: "fleet_description_response", fleetRequestId, result: { description } });
     }
@@ -3867,8 +4383,8 @@ export class FleetManager {
             return { error: "Fleet config not available" };
         if (!name || name.length > 30)
             return { error: "Name must be 1-30 characters" };
-        this.fleetConfig.instances[instance].display_name = name;
-        this.saveFleetConfig();
+        if (!this.setInstanceDisplayName(instance, name))
+            return { error: `Instance '${instance}' not found` };
         return { display_name: name };
     }
     async handleSetDescriptionHttp(instance, description) {
@@ -3876,8 +4392,8 @@ export class FleetManager {
             return { error: "Fleet config not available" };
         if (!description)
             return { error: "Description cannot be empty" };
-        this.fleetConfig.instances[instance].description = description;
-        this.saveFleetConfig();
+        if (!this.setInstanceDescription(instance, description))
+            return { error: `Instance '${instance}' not found` };
         return { description };
     }
     summarizeToolCall(tool, args) {
@@ -4009,7 +4525,8 @@ export class FleetManager {
     }
     /**
      * Patch only values changed in the effective config into the original YAML
-     * document. Unknown keys, explicit overrides and comments remain untouched.
+     * document. Unknown keys and comments remain untouched; redundant
+     * non-identity instance leaves are canonicalized to inheritance afterward.
      */
     saveFleetConfig(explicitPatches = []) {
         if (!this.fleetConfig || !this.configPath)
@@ -4025,9 +4542,9 @@ export class FleetManager {
         }
         this.rawFleetConfig = loadRawFleetConfig(this.configPath);
         this.patchFleetDocument(this.rawFleetDocument, [], this.savedFleetConfigSnapshot, this.fleetConfig);
-        // Settings edits are expressed against the raw config. Persist them even
-        // when the chosen override equals the inherited effective value, a case
-        // the before/after runtime diff cannot observe.
+        // Settings edits are expressed against the raw config, so apply them before
+        // canonicalization. A non-identity value equal to its inherited default is
+        // intentionally stored as inheritance rather than an explicit duplicate.
         for (const patch of explicitPatches) {
             if (patch.remove) {
                 // YAML's deleteIn throws when an inherited nested key has no raw parent
@@ -4042,7 +4559,24 @@ export class FleetManager {
                 this.patchFleetDocument(this.rawFleetDocument, patch.path, before, patch.value);
             }
         }
+        const rawAfterPatches = this.rawFleetDocument.toJS();
+        const redundantPaths = collectRedundantInstanceDefaultPaths(rawAfterPatches);
+        for (const path of redundantPaths) {
+            if (this.rawFleetDocument.hasIn(path))
+                this.rawFleetDocument.deleteIn(path);
+            // Avoid leaving empty operational maps such as `terminal: {}` while
+            // preserving the instance mapping itself and all surrounding comments.
+            for (let depth = path.length - 1; depth > 2; depth--) {
+                const parentPath = path.slice(0, depth);
+                const parent = this.rawFleetDocument.getIn(parentPath, true);
+                if (!isMap(parent) || parent.items.length > 0)
+                    break;
+                this.rawFleetDocument.deleteIn(parentPath);
+            }
+        }
         const output = String(this.rawFleetDocument);
+        if (redundantPaths.length > 0)
+            this.writeFleetConfigBackup(source);
         const tempPath = `${this.configPath}.tmp-${process.pid}`;
         writeFileSync(tempPath, output, "utf-8");
         if (existsSync(this.configPath))
@@ -4050,7 +4584,36 @@ export class FleetManager {
         renameSync(tempPath, this.configPath);
         this.rawFleetConfig = loadRawFleetConfig(this.configPath);
         this.savedFleetConfigSnapshot = structuredClone(this.fleetConfig);
-        this.logger.info({ path: this.configPath }, "Saved fleet config (lossless patch)");
+        this.logger.info({ path: this.configPath, strippedDefaults: redundantPaths.length }, "Saved fleet config (lossless patch)");
+    }
+    /** One-time upgrade migration; invalid YAML is never rewritten. */
+    slimFleetConfigAtStartup() {
+        const redundantPaths = collectRedundantInstanceDefaultPaths(this.rawFleetConfig);
+        if (redundantPaths.length === 0)
+            return;
+        const validation = validateFleetConfig(this.rawFleetConfig);
+        if (!validation.valid) {
+            this.logger.warn({ errors: validation.errors, redundantDefaults: redundantPaths.length }, "Skipping fleet.yaml default slimming because the raw config is invalid");
+            return;
+        }
+        try {
+            this.saveFleetConfig();
+            this.logger.info({ strippedDefaults: redundantPaths.length, backup: `${this.configPath}.bak` }, "Slimmed redundant instance defaults in fleet.yaml");
+        }
+        catch (err) {
+            // A migration must not turn a previously bootable fleet into an outage.
+            this.logger.warn({ err }, "Could not slim fleet.yaml; continuing with the original config");
+        }
+    }
+    writeFleetConfigBackup(source) {
+        if (!this.configPath)
+            return;
+        const backupPath = `${this.configPath}.bak`;
+        const tempPath = `${backupPath}.tmp-${process.pid}`;
+        writeFileSync(tempPath, source, "utf-8");
+        if (existsSync(this.configPath))
+            chmodSync(tempPath, statSync(this.configPath).mode);
+        renameSync(tempPath, backupPath);
     }
     patchFleetDocument(document, path, before, after) {
         if (Object.is(before, after))
@@ -4102,7 +4665,12 @@ export class FleetManager {
                 currentNode.value = after;
             }
             else {
-                document.setIn(path, after);
+                // Use a YAML collection node for newly-added objects. Passing the raw
+                // object creates a scalar wrapper: it serializes, but nested hasIn /
+                // deleteIn cannot traverse it (notably when slimming create_instance).
+                document.setIn(path, after !== null && typeof after === "object"
+                    ? document.createNode(after)
+                    : after);
             }
         }
     }
@@ -4193,7 +4761,7 @@ export class FleetManager {
                 from: primaryModel, to: fallbackModel, five_hour_pct: fiveHourPct,
             });
             this.webhookEmitter?.emit("model_failover", name, { from: primaryModel, to: fallbackModel, five_hour_pct: fiveHourPct });
-            this.notifyInstanceTopic(name, `⚡ Rate limit ${fiveHourPct}% — next rotation will use ${fallbackModel} (was ${primaryModel})`);
+            this.notifyInstanceTopic(name, t("failover.triggered", fiveHourPct, fallbackModel, primaryModel));
         }
         else if (fiveHourPct < FleetManager.FAILOVER_RECOVER_PCT && currentFailover) {
             // Recover: switch back to primary
@@ -4204,7 +4772,7 @@ export class FleetManager {
                 restored: primaryModel, five_hour_pct: fiveHourPct,
             });
             this.webhookEmitter?.emit("model_recovered", name, { restored: primaryModel, five_hour_pct: fiveHourPct });
-            this.notifyInstanceTopic(name, `✅ Rate limit recovered (${fiveHourPct}%) — next rotation will use ${primaryModel}`);
+            this.notifyInstanceTopic(name, t("failover.recovered", fiveHourPct, primaryModel));
         }
     }
     toggleFleetCollab(instanceName) {
@@ -4258,9 +4826,9 @@ export class FleetManager {
             if (output)
                 return output;
             if (e.code === "ENOENT") {
-                return "Backend doctor unavailable — agend CLI not found in PATH";
+                return t("doctor.cli_missing");
             }
-            return stripAnsi(e.message ?? "").trim() || "Doctor failed";
+            return stripAnsi(e.message ?? "").trim() || t("doctor.failed");
         }
     }
     /** Drop event/activity rows older than the retention window. Best-effort. */
@@ -4362,7 +4930,7 @@ export class FleetManager {
                 this.fleetErrorNotices.delete(oldest);
         }
         const body = suppressed > 0
-            ? `${text}\n(plus ${suppressed} more in the last ${Math.round(FleetManager.FLEET_ERROR_THROTTLE_MS / 60_000)}m)`
+            ? `${text}\n${t("fleet.error_suppressed", suppressed, Math.round(FleetManager.FLEET_ERROR_THROTTLE_MS / 60_000))}`
             : text;
         // Resolved from config, NOT findGeneralInstance(): that requires a live daemon,
         // and a fleet-level fault is exactly when the General may be down. The topic
@@ -4412,81 +4980,122 @@ export class FleetManager {
                 .catch(e => this.logger.warn({ err: e, instanceName }, "Failed to send notification (no topic)"));
         }
     }
-    interactivePromptLabel(kind) {
-        const key = `interactive.kind.${kind}`;
-        const translated = t(key);
-        return translated === key ? kind.replaceAll("_", " ") : translated;
-    }
+    // ── Nonce-armed button prompts (hang / assist / exit / clear) ──
+    //
+    // One shared lifecycle for every "notification with decision buttons":
+    // post with a 128-bit nonce, arm a bounded expiry, bind the click to the
+    // exact adapter+chat+thread+message that created it, require fleet admin for
+    // actions that mutate runtime state (Tips are the harmless exception),
+    // consume exactly once. The features differ only in what they post
+    // and what a consumed click does.
     /**
-     * Surface a stable terminal prompt in both places that matter:
-     * - the blocked instance gets a plain pointer to General;
-     * - General gets one-shot Confirm/Cancel controls on its own bound adapter.
-     *
-     * Only the prompt category crosses channels. The captured terminal line can
-     * contain usernames or secret-adjacent text and stays in daemon.log.
+     * Post decision buttons whose callback ids are `<prefix><nonce>:<action>`.
+     * The entry is registered before the send and rolled back if the send
+     * fails, so a nonce in the map always refers to a message that exists (or
+     * is about to). Returns the nonce, or null when the alert could not be sent.
      */
-    async notifyInteractivePrompt(instanceName, kind) {
-        this.notifyInstanceTopic(instanceName, t("interactive.instance_notice", instanceName));
-        // Multi-world fleets can have one General per bot/platform. Route the assist
-        // request to the General bound to the same adapter as the blocked instance.
-        const generalName = this.findGeneralInstance(this.getInstanceAdapterId(instanceName));
-        if (!generalName) {
-            this.logger.warn({ instanceName }, "Interactive prompt has no General topic notification target");
-            return;
-        }
-        const adapterId = this.getInstanceAdapterId(generalName);
-        const adapter = this.getAdapterForInstance(generalName);
-        const chatId = this.getGroupIdForInstance(generalName);
-        const topicId = this.fleetConfig?.instances[generalName]?.topic_id;
-        const threadId = topicId != null ? String(topicId) : undefined;
-        if (!adapter || !adapterId || !chatId) {
-            this.logger.warn({ instanceName, generalName, adapterId, chatId }, "Cannot address interactive prompt assistance controls");
-            return;
-        }
-        const nonce = randomBytes(8).toString("hex");
-        const label = this.interactivePromptLabel(kind);
+    async postNonceButtonPrompt(opts) {
+        // 16 bytes = the 128-bit capability the design claims. Telegram's 64-byte
+        // callback_data cap still holds: longest id is "interactive-assist:" (19)
+        // + 32 hex + ":confirm" (8) = 59 bytes.
+        const nonce = randomBytes(16).toString("hex");
         const entry = {
-            instanceName,
-            generalName,
-            kind,
-            adapterId,
-            adapter,
-            chatId,
-            threadId,
+            prefix: opts.prefix,
+            instanceName: opts.instanceName,
+            adapterId: opts.adapterId,
+            adapter: opts.adapter,
+            chatId: opts.chatId,
+            threadId: opts.threadId,
+            expiredText: opts.expiredText,
+            ...opts.extra,
         };
         entry.timer = setTimeout(() => {
-            const pending = this.pendingInteractivePromptAssists.get(nonce);
+            const pending = this.pendingNonceButtons.get(nonce);
             if (pending !== entry)
                 return;
-            this.pendingInteractivePromptAssists.delete(nonce);
+            this.pendingNonceButtons.delete(nonce);
             if (entry.messageId && entry.adapter.editMessageRemoveButtons) {
-                entry.adapter.editMessageRemoveButtons(entry.chatId, entry.messageId, t("interactive.expired", entry.instanceName), entry.threadId).catch(err => this.logger.debug({ err, instanceName }, "Failed to expire interactive prompt controls"));
+                entry.adapter.editMessageRemoveButtons(entry.chatId, entry.messageId, entry.expiredText, entry.threadId).catch(err => this.logger.debug({ err, instanceName: entry.instanceName, prefix: entry.prefix }, "Failed to expire button prompt"));
             }
-        }, INTERACTIVE_ASSIST_TIMEOUT_MS);
+        }, opts.timeoutMs ?? NONCE_BUTTON_TIMEOUT_MS);
         entry.timer.unref?.();
-        this.pendingInteractivePromptAssists.set(nonce, entry);
+        this.pendingNonceButtons.set(nonce, entry);
         try {
-            const sent = await adapter.notifyAlert(chatId, {
-                type: "interactive_prompt",
-                instanceName,
-                message: t("interactive.general_notice", instanceName, label),
-                choices: [
-                    { id: `${INTERACTIVE_ASSIST_CALLBACK_PREFIX}${nonce}:confirm`, label: t("interactive.confirm") },
-                    { id: `${INTERACTIVE_ASSIST_CALLBACK_PREFIX}${nonce}:cancel`, label: t("interactive.cancel") },
-                ],
-            }, threadId ? { threadId } : undefined);
+            const sent = await opts.adapter.notifyAlert(opts.chatId, {
+                type: opts.alertType,
+                instanceName: opts.instanceName,
+                message: opts.message,
+                choices: opts.choices.map(c => ({ id: `${opts.prefix}${nonce}:${c.action}`, label: c.label })),
+            }, opts.threadId ? { threadId: opts.threadId } : undefined);
             entry.messageId = sent.messageId;
+            return nonce;
         }
         catch (err) {
-            this.pendingInteractivePromptAssists.delete(nonce);
+            this.pendingNonceButtons.delete(nonce);
             if (entry.timer)
                 clearTimeout(entry.timer);
-            this.logger.warn({ err, instanceName, generalName }, "Failed to send interactive prompt assistance controls");
+            this.logger.warn({ err, instanceName: opts.instanceName, prefix: opts.prefix }, "Failed to send button prompt");
+            return null;
+        }
+    }
+    /**
+     * Claim a nonce-armed callback exactly once.
+     *
+     * Returns:
+     *  - null       — the callback is not for this prefix; try the next handler
+     *  - "consumed" — for this prefix but stale/denied/malformed; stop dispatch
+     *  - the entry+action — the click is authorized and now claimed (removed
+     *    from the map before any await, so double clicks cannot act twice)
+     *
+     * A stale click (expired nonce, or a pre-upgrade button whose payload no
+     * longer parses) collapses the clicked message so the dead button stops
+     * inviting clicks — the same courtesy the cancel button extends.
+     */
+    consumeNonceCallback(prefix, actionRe, data, callbackAdapterId, receivingAdapter) {
+        if (!data.callbackData.startsWith(prefix))
+            return null;
+        const match = data.callbackData.match(actionRe);
+        let pending = match ? this.pendingNonceButtons.get(match[1]) : undefined;
+        // The map is shared across prompt kinds. A nonce that resolves to an entry
+        // of a DIFFERENT kind is not a usable capability for this handler — treat
+        // it as stale rather than acting across kinds (fail closed).
+        if (pending && pending.prefix !== prefix)
+            pending = undefined;
+        if (!match || !pending) {
+            const adapter = receivingAdapter ?? this.adapter;
+            adapter?.editMessageRemoveButtons?.(data.chatId, data.messageId, t("buttons.stale"), data.threadId).catch(() => { });
+            return "consumed";
+        }
+        // Bind the capability to the exact message/world that created it. Telegram
+        // keyboards are visible to everyone, so mutating actions require fleet admin;
+        // a Tip acknowledgement only records that the shared content was read.
+        const isAuthorized = data.userId
+            ? pending.allowAnyUser
+                ? true
+                : pending.authChannelId
+                    ? this.isModelAdmin(data.userId, pending.authChannelId, callbackAdapterId)
+                    : this.isFleetAdmin(data.userId, callbackAdapterId)
+            : false;
+        if (pending.adapterId !== callbackAdapterId
+            || data.chatId !== pending.chatId
+            || (pending.threadId != null && data.threadId !== pending.threadId)
+            || (pending.messageId != null && data.messageId !== pending.messageId)
+            || !isAuthorized) {
+            // Deliberately does NOT consume the nonce: the real admin can still click.
+            this.logger.warn({ instanceName: pending.instanceName, prefix, userId: data.userId }, "Rejected unauthorized or mismatched button callback");
+            return "consumed";
         }
+        // Claim before any await: double clicks and duplicate callback delivery can
+        // never act twice.
+        this.pendingNonceButtons.delete(match[1]);
+        if (pending.timer)
+            clearTimeout(pending.timer);
+        return { entry: pending, action: match[2] };
     }
-    async retireInteractivePromptButtons(pending, messageId, text) {
+    /** Collapse a consumed prompt's buttons into a final status line. */
+    async retireNonceButtons(pending, messageId, text) {
         if (!pending.adapter.editMessageRemoveButtons) {
-            this.logger.warn({ instanceName: pending.instanceName, adapterId: pending.adapterId }, "Adapter cannot remove interactive prompt controls");
+            this.logger.warn({ instanceName: pending.instanceName, adapterId: pending.adapterId }, "Adapter cannot remove prompt buttons");
             return;
         }
         try {
@@ -4494,58 +5103,395 @@ export class FleetManager {
         }
         catch (err) {
             // The action was already atomically consumed. An edit failure must not
-            // prevent Confirm from reaching General or make Cancel actionable again.
-            this.logger.warn({ err, instanceName: pending.instanceName }, "Failed to retire interactive prompt controls");
+            // undo that or make the button actionable again.
+            this.logger.warn({ err, instanceName: pending.instanceName }, "Failed to retire prompt buttons");
         }
     }
-    /** Consume a General assist button exactly once. */
-    async handleInteractivePromptAssist(data, callbackAdapterId) {
-        if (!data.callbackData.startsWith(INTERACTIVE_ASSIST_CALLBACK_PREFIX))
+    tipsEnabled() {
+        return this.fleetConfig?.defaults.tips !== false;
+    }
+    readTipState() {
+        if (!this.scheduler)
+            return null;
+        try {
+            return {
+                dismissed: this.scheduler.db.listDismissedTipIds(),
+                advancedUnlocked: this.scheduler.db.isAdvancedTipsUnlocked(),
+            };
+        }
+        catch (err) {
+            // Tips are additive. A damaged/locked scheduler DB must never block fleet
+            // startup, update completion, or a General command.
+            this.logger.warn({ err }, "Failed to read tip state");
+            return null;
+        }
+    }
+    pickAvailableTip() {
+        const state = this.readTipState();
+        return state ? selectTip(state.dismissed, Math.random, state.advancedUnlocked) : null;
+    }
+    tipText(tip) {
+        return getLocale() === "zh-TW" ? tip.text_zh : tip.text_en;
+    }
+    formatTip(tip) {
+        return `💡 ${t("tips.label")}: ${this.tipText(tip)}`;
+    }
+    /** Persistently enable advanced tips through the admin-only slash command. */
+    unlockAdvancedTips(userId) {
+        if (!this.scheduler)
             return false;
-        const match = data.callbackData.match(/^interactive-assist:([0-9a-f]+):(confirm|cancel)$/);
-        if (!match)
+        try {
+            this.scheduler.db.unlockAdvancedTips(userId);
+            this.eventLog?.insert(this.findGeneralInstance() ?? "general", "tips_advanced_unlocked", {
+                userId,
+                source: "command",
+            });
             return true;
-        const pending = this.pendingInteractivePromptAssists.get(match[1]);
-        if (!pending)
+        }
+        catch (err) {
+            this.logger.warn({ err, userId }, "Failed to unlock advanced tips from command");
+            return false;
+        }
+    }
+    /** Post one fresh nonce-armed tip in a known General channel. */
+    async promptTip(generalName, adapter, chatId, threadId) {
+        const state = this.readTipState();
+        if (!state)
+            return "unavailable";
+        if (!state.advancedUnlocked && canUnlockAdvancedTips(state.dismissed)) {
+            return await this.promptAdvancedTipUnlock(generalName, adapter, chatId, threadId)
+                ? "posted"
+                : "unavailable";
+        }
+        const tip = selectTip(state.dismissed, Math.random, state.advancedUnlocked);
+        if (!tip)
+            return this.scheduler ? "empty" : "unavailable";
+        const nonce = await this.postNonceButtonPrompt({
+            prefix: TIP_DISMISS_CALLBACK_PREFIX,
+            alertType: "tip",
+            instanceName: generalName,
+            adapter,
+            adapterId: adapter.id,
+            chatId,
+            threadId,
+            message: this.formatTip(tip),
+            choices: [{ action: "dismiss", label: t("tips.dismiss") }],
+            // Expiry removes only the stale button; the useful tip remains readable.
+            expiredText: this.formatTip(tip),
+            extra: { allowAnyUser: true, tipId: tip.id },
+            timeoutMs: TIP_BUTTON_TIMEOUT_MS,
+        });
+        return nonce ? "posted" : "unavailable";
+    }
+    async promptAdvancedTipUnlock(generalName, adapter, chatId, threadId) {
+        const nonce = await this.postNonceButtonPrompt({
+            prefix: TIP_UNLOCK_CALLBACK_PREFIX,
+            alertType: "tip",
+            instanceName: generalName,
+            adapter,
+            adapterId: adapter.id,
+            chatId,
+            threadId,
+            message: t("tips.advanced.unlock_prompt"),
+            choices: [{ action: "unlock", label: t("tips.advanced.unlock") }],
+            expiredText: t("tips.advanced.expired"),
+            extra: { allowAnyUser: true },
+            timeoutMs: TIP_BUTTON_TIMEOUT_MS,
+        });
+        return nonce !== null;
+    }
+    async sendTipToGeneral() {
+        if (!this.tipsEnabled())
+            return;
+        const generalName = this.findGeneralInstance();
+        if (!generalName)
+            return;
+        const adapter = this.getAdapterForInstance(generalName);
+        const chatId = this.getGroupIdForInstance(generalName);
+        const topicId = this.fleetConfig?.instances[generalName]?.topic_id;
+        if (!adapter || !chatId)
+            return;
+        const result = await this.promptTip(generalName, adapter, chatId, topicId != null ? String(topicId) : undefined);
+        if (result === "unavailable") {
+            this.logger.warn({ generalName }, "Daily tip could not be posted");
+        }
+    }
+    async handleTipDismiss(data, callbackAdapterId, receivingAdapter) {
+        const claimed = this.consumeNonceCallback(TIP_DISMISS_CALLBACK_PREFIX, /^tip-dismiss:([0-9a-f]+):(dismiss)$/, data, callbackAdapterId, receivingAdapter);
+        if (claimed === null)
+            return false;
+        if (claimed === "consumed")
             return true;
-        // Bind the capability to the exact message/world that created it. Telegram
-        // keyboards are visible to everyone, so the click also requires fleet admin.
-        if (pending.adapterId !== callbackAdapterId
-            || data.chatId !== pending.chatId
-            || (pending.threadId != null && data.threadId !== pending.threadId)
-            || (pending.messageId != null && data.messageId !== pending.messageId)
-            || !data.userId
-            || !this.isFleetAdmin(data.userId, callbackAdapterId)) {
-            this.logger.warn({ instanceName: pending.instanceName, userId: data.userId }, "Rejected unauthorized or mismatched interactive prompt callback");
+        const { entry: pending } = claimed;
+        if (!pending.tipId || !data.userId || !this.scheduler) {
+            this.logger.error({ tipId: pending.tipId, userId: data.userId }, "Tip dismissal has incomplete persistence context");
+            await this.retireNonceButtons(pending, pending.messageId ?? data.messageId, t("tips.unavailable"));
             return true;
         }
-        // Claim before any await: double clicks and duplicate callback delivery can
-        // never inject two messages into General.
-        this.pendingInteractivePromptAssists.delete(match[1]);
-        if (pending.timer)
-            clearTimeout(pending.timer);
-        const action = match[2];
+        try {
+            this.scheduler.db.dismissTip(data.userId, pending.tipId);
+        }
+        catch (err) {
+            this.logger.warn({ err, tipId: pending.tipId, userId: data.userId }, "Failed to persist tip dismissal");
+            await this.retireNonceButtons(pending, pending.messageId ?? data.messageId, t("tips.unavailable"));
+            return true;
+        }
+        this.eventLog?.insert(pending.instanceName, "tip_dismissed", {
+            tipId: pending.tipId,
+            userId: data.userId,
+        });
+        await this.retireNonceButtons(pending, pending.messageId ?? data.messageId, 
+        // Dismissal changes future selection only. Keep the useful tip text in
+        // chat history and remove just the now-consumed button.
+        pending.expiredText);
+        const state = this.readTipState();
+        if (state && !state.advancedUnlocked && canUnlockAdvancedTips(state.dismissed)) {
+            await this.promptAdvancedTipUnlock(pending.instanceName, pending.adapter, pending.chatId, pending.threadId);
+        }
+        return true;
+    }
+    async handleTipUnlock(data, callbackAdapterId, receivingAdapter) {
+        const claimed = this.consumeNonceCallback(TIP_UNLOCK_CALLBACK_PREFIX, /^tip-unlock:([0-9a-f]+):(unlock)$/, data, callbackAdapterId, receivingAdapter);
+        if (claimed === null)
+            return false;
+        if (claimed === "consumed")
+            return true;
+        const { entry: pending } = claimed;
+        if (!data.userId || !this.scheduler) {
+            await this.retireNonceButtons(pending, pending.messageId ?? data.messageId, t("tips.unavailable"));
+            return true;
+        }
+        try {
+            this.scheduler.db.unlockAdvancedTips(data.userId);
+        }
+        catch (err) {
+            this.logger.warn({ err, userId: data.userId }, "Failed to unlock advanced tips");
+            await this.retireNonceButtons(pending, pending.messageId ?? data.messageId, t("tips.unavailable"));
+            return true;
+        }
+        this.eventLog?.insert(pending.instanceName, "tips_advanced_unlocked", { userId: data.userId });
+        await this.retireNonceButtons(pending, pending.messageId ?? data.messageId, t("tips.advanced.unlocked"));
+        return true;
+    }
+    /** Post the destructive `/clear` confirmation in the invoking channel. */
+    async promptClearConfirmation(instanceName, channelId, adapter, chatId, threadId) {
+        if (!this.topicCommands.supportsClear(instanceName))
+            return t("clear.unsupported");
+        const adapterId = adapter.id;
+        if (!adapterId)
+            return t("clear.prompt_unavailable");
+        const nonce = await this.postNonceButtonPrompt({
+            prefix: CLEAR_CONFIRM_CALLBACK_PREFIX,
+            alertType: "clear_confirm",
+            instanceName,
+            adapter,
+            adapterId,
+            chatId,
+            threadId,
+            message: t("clear.confirm_message", instanceName),
+            choices: [
+                { action: "confirm", label: t("clear.confirm") },
+                { action: "cancel", label: t("clear.cancel") },
+            ],
+            expiredText: t("clear.expired", instanceName),
+            extra: { authChannelId: channelId },
+            timeoutMs: CLEAR_CONFIRM_TIMEOUT_MS,
+        });
+        return nonce ? null : t("clear.prompt_unavailable");
+    }
+    /** Consume `/clear` Confirm/Cancel exactly once; only Confirm reaches IPC. */
+    async handleClearConfirmation(data, callbackAdapterId, receivingAdapter) {
+        const claimed = this.consumeNonceCallback(CLEAR_CONFIRM_CALLBACK_PREFIX, /^clear-confirm:([0-9a-f]+):(confirm|cancel)$/, data, callbackAdapterId, receivingAdapter);
+        if (claimed === null)
+            return false;
+        if (claimed === "consumed")
+            return true;
+        const { entry: pending, action } = claimed;
+        this.eventLog?.insert(pending.instanceName, "clear_action", { action, userId: data.userId });
+        if (action === "cancel") {
+            await this.retireNonceButtons(pending, pending.messageId ?? data.messageId, t("clear.cancelled", pending.instanceName));
+            return true;
+        }
+        await this.retireNonceButtons(pending, pending.messageId ?? data.messageId, t("clear.clearing", pending.instanceName));
+        try {
+            const result = await this.topicCommands.sendClear(pending.instanceName);
+            await pending.adapter.editMessage(pending.chatId, pending.messageId ?? data.messageId, result, pending.threadId);
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            this.logger.error({ err, instanceName: pending.instanceName }, "Clear command failed");
+            await pending.adapter.editMessage(pending.chatId, pending.messageId ?? data.messageId, t("clear.failed", pending.instanceName, message), pending.threadId).catch(editErr => this.logger.warn({ err: editErr, instanceName: pending.instanceName }, "Failed to show clear command error"));
+        }
+        return true;
+    }
+    /**
+     * Drop every pending prompt that refers to an instance being stopped or
+     * restarted — a restart offer for an instance the operator just restarted
+     * (or an assist for one they stopped) must not stay clickable for the rest
+     * of its 15 minutes.
+     */
+    clearNoncePromptsForInstance(instanceName) {
+        for (const [nonce, entry] of this.pendingNonceButtons) {
+            if (entry.instanceName !== instanceName)
+                continue;
+            this.pendingNonceButtons.delete(nonce);
+            if (entry.timer)
+                clearTimeout(entry.timer);
+            if (entry.messageId && entry.adapter.editMessageRemoveButtons) {
+                entry.adapter.editMessageRemoveButtons(entry.chatId, entry.messageId, entry.expiredText, entry.threadId)
+                    .catch(err => this.logger.debug({ err, instanceName, prefix: entry.prefix }, "Failed to collapse prompt during instance stop"));
+            }
+        }
+    }
+    /** A clean exit is intentional from the CLI's perspective, but often not from
+     * the operator's. Keep the instance notice passive and put the action in the
+     * same-world General topic where an administrator can make the choice. */
+    async notifyNormalExit(instanceName) {
+        this.notifyInstanceTopic(instanceName, t("exit.instance_notice", instanceName));
+        const worldId = this.getInstanceAdapterId(instanceName);
+        const generalName = this.findGeneralInstance(worldId);
+        if (!generalName) {
+            this.logger.warn({ instanceName, worldId }, "Normal CLI exit has no General notification target");
+            return;
+        }
+        const adapterId = this.getInstanceAdapterId(generalName);
+        const adapter = this.getAdapterForInstance(generalName);
+        const chatId = this.getGroupIdForInstance(generalName);
+        const topicId = this.fleetConfig?.instances[generalName]?.topic_id;
+        const threadId = topicId != null ? String(topicId) : undefined;
+        if (!adapter || !adapterId || !chatId) {
+            this.logger.warn({ instanceName, generalName, adapterId, chatId }, "Cannot address normal-exit restart controls");
+            return;
+        }
+        await this.postNonceButtonPrompt({
+            prefix: EXIT_RESTART_CALLBACK_PREFIX,
+            alertType: "exit_restart",
+            instanceName,
+            adapter,
+            adapterId,
+            chatId,
+            threadId,
+            message: t("exit.general_notice", instanceName),
+            choices: [
+                { action: "restart", label: t("exit.restart") },
+                { action: "ignore", label: t("exit.ignore") },
+            ],
+            expiredText: t("exit.expired", instanceName),
+        });
+    }
+    /** Consume a clean-exit Restart/Ignore button exactly once. */
+    async handleExitRestartPrompt(data, callbackAdapterId, receivingAdapter) {
+        const claimed = this.consumeNonceCallback(EXIT_RESTART_CALLBACK_PREFIX, /^exit-restart:([0-9a-f]+):(restart|ignore)$/, data, callbackAdapterId, receivingAdapter);
+        if (claimed === null)
+            return false;
+        if (claimed === "consumed")
+            return true;
+        const { entry: pending, action } = claimed;
+        this.eventLog?.insert(pending.instanceName, "normal_exit_action", { action, userId: data.userId });
+        if (action === "ignore") {
+            await this.retireNonceButtons(pending, pending.messageId ?? data.messageId, t("exit.ignored", pending.instanceName));
+            return true;
+        }
+        await this.retireNonceButtons(pending, pending.messageId ?? data.messageId, t("exit.restarting", pending.instanceName));
+        try {
+            await this.restartSingleInstance(pending.instanceName);
+            await pending.adapter.editMessage(pending.chatId, pending.messageId ?? data.messageId, t("exit.restarted", pending.instanceName), pending.threadId);
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            this.logger.error({ err, instanceName: pending.instanceName }, "Normal-exit restart failed");
+            await pending.adapter.editMessage(pending.chatId, pending.messageId ?? data.messageId, t("exit.restart_failed", pending.instanceName, message), pending.threadId).catch(editErr => this.logger.warn({ err: editErr, instanceName: pending.instanceName }, "Failed to show normal-exit restart error"));
+        }
+        return true;
+    }
+    interactivePromptLabel(kind) {
+        const key = `interactive.kind.${kind}`;
+        const translated = t(key);
+        return translated === key ? kind.replaceAll("_", " ") : translated;
+    }
+    /**
+     * Surface a stable terminal prompt in both places that matter:
+     * - the blocked instance gets a plain pointer to General;
+     * - General gets one-shot Confirm/Cancel controls on its own bound adapter.
+     *
+     * Only the prompt category crosses channels. The captured terminal line can
+     * contain usernames or secret-adjacent text and stays in daemon.log.
+     */
+    async notifyInteractivePrompt(instanceName, kind) {
+        this.notifyInstanceTopic(instanceName, t("interactive.instance_notice", instanceName));
+        // Multi-world fleets can have one General per bot/platform. Route the assist
+        // request to the General bound to the same adapter as the blocked instance.
+        const generalName = this.findGeneralInstance(this.getInstanceAdapterId(instanceName));
+        if (!generalName) {
+            this.logger.warn({ instanceName }, "Interactive prompt has no General topic notification target");
+            return;
+        }
+        const adapterId = this.getInstanceAdapterId(generalName);
+        const adapter = this.getAdapterForInstance(generalName);
+        const chatId = this.getGroupIdForInstance(generalName);
+        const topicId = this.fleetConfig?.instances[generalName]?.topic_id;
+        const threadId = topicId != null ? String(topicId) : undefined;
+        if (!adapter || !adapterId || !chatId) {
+            this.logger.warn({ instanceName, generalName, adapterId, chatId }, "Cannot address interactive prompt assistance controls");
+            return;
+        }
+        const label = this.interactivePromptLabel(kind);
+        await this.postNonceButtonPrompt({
+            prefix: INTERACTIVE_ASSIST_CALLBACK_PREFIX,
+            alertType: "interactive_prompt",
+            instanceName,
+            adapter,
+            adapterId,
+            chatId,
+            threadId,
+            message: t("interactive.general_notice", instanceName, label),
+            choices: [
+                { action: "confirm", label: t("interactive.confirm") },
+                { action: "cancel", label: t("interactive.cancel") },
+            ],
+            expiredText: t("interactive.expired", instanceName),
+            extra: { generalName, promptKind: kind },
+        });
+    }
+    /** Consume a General assist button exactly once. */
+    async handleInteractivePromptAssist(data, callbackAdapterId, receivingAdapter) {
+        const claimed = this.consumeNonceCallback(INTERACTIVE_ASSIST_CALLBACK_PREFIX, /^interactive-assist:([0-9a-f]+):(confirm|cancel)$/, data, callbackAdapterId, receivingAdapter);
+        if (claimed === null)
+            return false;
+        if (claimed === "consumed")
+            return true;
+        const { entry: pending, action } = claimed;
         this.eventLog?.insert(pending.instanceName, "interactive_prompt_assist", {
             action,
             userId: data.userId,
             generalName: pending.generalName,
         });
         if (action === "cancel") {
-            await this.retireInteractivePromptButtons(pending, pending.messageId ?? data.messageId, t("interactive.ignored", pending.instanceName));
+            await this.retireNonceButtons(pending, pending.messageId ?? data.messageId, t("interactive.ignored", pending.instanceName));
+            return true;
+        }
+        // Fail closed on a malformed entry. generalName is set at posting time for
+        // every interactive-assist entry; its absence means entry confusion, and
+        // falling back to the blocked instance would type the assist text into the
+        // very terminal prompt this feature exists to keep humans in front of.
+        const generalName = pending.generalName;
+        if (!generalName) {
+            this.logger.error({ instanceName: pending.instanceName }, "Interactive-assist entry has no General target — refusing to deliver");
+            await this.retireNonceButtons(pending, pending.messageId ?? data.messageId, t("interactive.delivery_failed", pending.instanceName));
             return true;
         }
         // Injecting into General while General itself is blocked would type into the
         // terminal prompt instead of the agent input. Fail safe and require attach.
-        if (pending.instanceName === pending.generalName) {
-            await this.retireInteractivePromptButtons(pending, pending.messageId ?? data.messageId, t("interactive.self_assist", pending.instanceName));
+        if (pending.instanceName === generalName) {
+            await this.retireNonceButtons(pending, pending.messageId ?? data.messageId, t("interactive.self_assist", pending.instanceName));
             return true;
         }
-        await this.retireInteractivePromptButtons(pending, pending.messageId ?? data.messageId, t("interactive.confirmed", pending.instanceName));
+        await this.retireNonceButtons(pending, pending.messageId ?? data.messageId, t("interactive.confirmed", pending.instanceName));
         try {
-            await this.deliverToInstance(pending.generalName, {
+            await this.deliverToInstance(generalName, {
                 type: "fleet_inbound",
-                content: t("interactive.assist_request", pending.instanceName, this.interactivePromptLabel(pending.kind)),
-                targetSession: pending.generalName,
+                content: t("interactive.assist_request", pending.instanceName, this.interactivePromptLabel(pending.promptKind ?? "")),
+                targetSession: generalName,
                 meta: {
                     chat_id: pending.chatId,
                     message_id: pending.messageId ?? data.messageId,
@@ -4604,7 +5550,7 @@ export class FleetManager {
         const force = target.kind === "classic" && !!data.options?.force;
         const cmd = saveCommandForBackend(backend, filename, force);
         if (!cmd) {
-            await data.respond(SAVE_UNSUPPORTED_MSG);
+            await data.respond(t("save.unsupported"));
             return;
         }
         if (target.kind === "classic") {
@@ -4657,7 +5603,7 @@ export class FleetManager {
         }
         return false;
     }
-    async sendCancelButton(instanceName, correlationId) {
+    async sendCancelButton(instanceName, correlationId, preserveProgress = false) {
         // Post first, retire after (see the tail of this method). Retiring up front
         // meant that from the delete until the new message came back — a chat API
         // round trip, and every reply goes through here — the instance had NO live
@@ -4718,6 +5664,10 @@ export class FleetManager {
                 // not re-edit identical text — which put a "(edited)" mark on Discord
                 // with nothing visibly changed.
                 lastProgressText: "👀 處理中…",
+                // A reply can re-post the same in-flight bubble below the reply. Carry
+                // its current list into that replacement; fresh inbound work must start
+                // empty even if the daemon's reset broadcast is still in flight.
+                toolProgress: preserveProgress ? this.instanceProgress.get(instanceName) : undefined,
             };
             this.startProgressTicker(entry);
             // Idle-check backstop: every 5min, if the instance is idle, retire the
@@ -4771,16 +5721,28 @@ export class FleetManager {
     static progressText(elapsedMs, activity, minElapsedMs = PROGRESS_MIN_ELAPSED_MS) {
         if (elapsedMs < minElapsedMs)
             return "👀 處理中…";
+        const elapsed = FleetManager.formatProgressElapsed(elapsedMs);
+        const detail = FleetManager.sanitizeActivity(activity);
+        return detail
+            ? `⏳ 處理中… (已進行 ${elapsed} · ${detail})`
+            : `⏳ 處理中… (已進行 ${elapsed})`;
+    }
+    /** Render elapsed time consistently in live and retained progress bubbles. */
+    static formatProgressElapsed(elapsedMs) {
         const totalSeconds = Math.floor(elapsedMs / 1000);
         const minutes = Math.floor(totalSeconds / 60);
         const seconds = totalSeconds % 60;
-        const elapsed = minutes >= 60
+        return minutes >= 60
             ? `${Math.floor(minutes / 60)}h ${minutes % 60}m`
             : `${minutes}m ${String(seconds).padStart(2, "0")}s`;
-        const detail = FleetManager.sanitizeActivity(activity);
-        return detail
-            ? `⏳ 處理中… (已進行 ${elapsed} · ${detail})`
-            : `⏳ 處理中… (已進行 ${elapsed})`;
+    }
+    /** Final read-only form of a bubble that contains semantic tool history.
+     * Neutral wording is intentional: the same retirement primitive is used for
+     * normal completion, a mid-turn bubble replacement, and user cancellation,
+     * so claiming every retained checkpoint is "completed" would be false. */
+    composeRetiredBubbleText(entry) {
+        const elapsed = FleetManager.formatProgressElapsed(Date.now() - (entry.startedAt ?? Date.now()));
+        return `🧾 工具歷程 (記錄至 ${elapsed})\n${entry.toolProgress}`;
     }
     /**
      * Make a tool summary safe to paste into a channel message.
@@ -4813,6 +5775,88 @@ 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)
+                continue;
+            // Empty means the daemon completed/reset the turn. Clear the live cache
+            // for the next turn, but retain this bubble's last non-empty list so its
+            // retirement can preserve the history instead of deleting the message.
+            if (progress)
+                entry.toolProgress = progress;
+            this.scheduleProgressEdit(entry);
+        }
+    }
+    /** At most one progress-driven edit per bubble per TOOL_PROGRESS_EDIT_MIN_MS. */
+    scheduleProgressEdit(entry) {
+        if (entry.retiring)
+            return;
+        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(), entry.toolProgress);
+    }
+    /** 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 (entry.retiring || !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.
      *
@@ -4830,31 +5874,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
@@ -4868,8 +5888,11 @@ export class FleetManager {
     }
     /**
      * After a reply: give the instance REPLY_RETIRE_GRACE_MS to resume working; if
-     * it has not, retire its button. Re-arming replaces the previous timer, so a
-     * burst of replies ends with exactly one pending check.
+     * it has not, retire its button. The daemon is asked for a fresh pane capture
+     * before deciding. Reading only the transition cache stranded the first
+     * post-restart bubble when its startup "working" report never got a matching
+     * idle edge. Re-arming replaces the previous timer, so a burst of replies ends
+     * with exactly one pending check.
      */
     armReplyGrace(instanceName) {
         for (const entry of this.cancelButtons.values()) {
@@ -4881,14 +5904,26 @@ export class FleetManager {
                 entry.replyGraceTimer = undefined;
                 if (!this.cancelButtons.has(entry.messageId))
                     return;
-                if (!this.getInstanceIdle(instanceName))
-                    return; // resumed — a long run keeps its button
-                this.logger.info({ instanceName, messageId: entry.messageId }, "Cancel button retired — no work resumed after reply");
-                this.retireButton(entry);
+                void this.finishReplyGrace(instanceName, entry);
             }, REPLY_RETIRE_GRACE_MS);
             entry.replyGraceTimer.unref?.();
         }
     }
+    async finishReplyGrace(instanceName, entry) {
+        const refreshed = await this.refreshInstanceExecutionState(instanceName, REPLY_STATE_REFRESH_TIMEOUT_MS);
+        if (!this.cancelButtons.has(entry.messageId) || entry.retiring)
+            return;
+        if (!refreshed) {
+            // Fail safe: without an authoritative answer, retain a potentially live
+            // Cancel button. The 5-minute/30-minute/24-hour safety nets still apply.
+            this.logger.debug({ instanceName, messageId: entry.messageId }, "Cancel reply-grace state refresh timed out");
+            return;
+        }
+        if (!this.getInstanceIdle(instanceName))
+            return; // genuine long run keeps its button
+        this.logger.info({ instanceName, messageId: entry.messageId }, "Cancel button retired — no work resumed after reply");
+        this.retireButton(entry);
+    }
     /** Retire (delete) every cancel button belonging to an instance. */
     retireInstanceButtons(instanceName) {
         // Snapshot first — retireButton may delete entries from the map on success.
@@ -4910,7 +5945,7 @@ export class FleetManager {
         this.deleteButtonMessage(entry)
             .then(() => {
             this.discardButton(entry);
-            this.logger.info({ instanceName: entry.instanceName, messageId: entry.messageId }, "Cancel button removed");
+            this.logger.info({ instanceName: entry.instanceName, messageId: entry.messageId, historyPreserved: Boolean(entry.toolProgress) }, "Cancel button retired");
         })
             .catch((err) => this.scheduleButtonRetry(entry, err));
     }
@@ -4922,6 +5957,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);
@@ -4999,12 +6036,21 @@ export class FleetManager {
         // Continue the same retire cycle (bypass the retiring-guard in retireButton).
         entry.retryTimer = setTimeout(() => this.attemptButtonDelete(entry), CANCEL_BTN_RETRY_INTERVAL_MS);
     }
-    /** Delete one button's message via its own adapter. Resolves on success,
+    /** Retire one cancel bubble via its own adapter. A bubble that accumulated
+     * tool progress is kept as a read-only history message; a plain bubble keeps
+     * the legacy delete/edit-to-checkmark behavior. Resolves on success and
      * rejects on failure so the caller can retry. */
     deleteButtonMessage(e) {
         const adapter = (e.adapterId ? this.worlds.get(e.adapterId)?.adapter : undefined) ?? this.adapter;
         if (!adapter)
             return Promise.reject(new Error("no adapter for cancel button"));
+        if (e.toolProgress && adapter.editMessageRemoveButtons) {
+            return adapter.editMessageRemoveButtons(e.chatId, e.messageId, this.composeRetiredBubbleText(e), e.threadId);
+        }
+        // All production adapters currently implement editMessageRemoveButtons.
+        // A third-party adapter without it degrades to the legacy delete behavior:
+        // removing a live Cancel control is safer than retaining an actionable,
+        // untracked button forever.
         if (adapter.deleteMessage)
             return adapter.deleteMessage(e.chatId, e.messageId, e.threadId);
         if (adapter.editMessageRemoveButtons)
@@ -5056,11 +6102,27 @@ export class FleetManager {
         const daemon = this.daemons.get(instanceName);
         if (!daemon)
             return false;
+        const deliveryEpoch = this.cancelPendingDeliveries(instanceName);
+        daemon.clearPendingDeliveries?.(deliveryEpoch);
         daemon.sendEscape().catch(e => this.logger.warn({ err: e, instanceName }, "sendEscape failed"));
         this.lastInboundMsg.delete(instanceName);
         this.clearCancelButton(instanceName);
         return true;
     }
+    getDeliveryEpoch(instanceName) {
+        return this.deliveryEpochs.get(instanceName) ?? 0;
+    }
+    isDeliveryEpochCurrent(instanceName, deliveryEpoch) {
+        return deliveryEpoch === this.getDeliveryEpoch(instanceName);
+    }
+    /** Invalidate work queued before a user cancel and wake idle-gate waiters. */
+    cancelPendingDeliveries(instanceName) {
+        const next = this.getDeliveryEpoch(instanceName) + 1;
+        this.deliveryEpochs.set(instanceName, next);
+        for (const check of this.instanceIdleWaiters.get(instanceName) ?? [])
+            check();
+        return next;
+    }
     queueMirrorMessage(text) {
         const mirrorTopicId = this.fleetConfig?.channel?.mirror_topic_id;
         if (mirrorTopicId == null || !this.adapter)
@@ -5095,13 +6157,29 @@ export class FleetManager {
     }
     async sendHangNotification(instanceName, unchangedForMs) {
         const adapter = this.getAdapterForInstance(instanceName) ?? this.adapter;
-        if (!adapter)
-            return;
-        const channelCfg = this.getChannelConfig(this.getInstanceAdapterId(instanceName));
-        const groupId = channelCfg?.group_id;
-        if (!groupId)
+        const adapterId = this.getInstanceAdapterId(instanceName);
+        // Same three-way addressing as sendCancelButton: fleet topic → group+thread,
+        // Classic → its own channel (Classic instances are absent from
+        // fleetConfig.instances, so the topic path can never address them), else the
+        // world group flat. getGroupIdForInstance (not getChannelConfig().group_id)
+        // because on channels[]-configured fleets the legacy channel: block is empty.
+        const topicId = this.fleetConfig?.instances[instanceName]?.topic_id;
+        const groupId = this.getGroupIdForInstance(instanceName) || undefined;
+        let chatId;
+        let threadId;
+        if (topicId != null && groupId) {
+            chatId = String(groupId);
+            threadId = String(topicId);
+        }
+        else {
+            chatId = this.classicChannels?.getChannelIdByInstance(instanceName);
+            if (!chatId && groupId)
+                chatId = String(groupId);
+        }
+        if (!adapter || !adapterId || !chatId) {
+            this.logger.warn({ instanceName, adapterId, chatId }, "Cannot address hang notification");
             return;
-        const threadId = this.fleetConfig?.instances[instanceName]?.topic_id;
+        }
         const instanceHangConfig = this.fleetConfig?.instances[instanceName]?.hang_detector;
         const configuredMinutes = instanceHangConfig?.timeout_minutes
             ?? this.fleetConfig?.defaults?.hang_detector?.timeout_minutes
@@ -5110,17 +6188,52 @@ export class FleetManager {
             ? configuredMinutes
             : Math.max(1, Math.floor(unchangedForMs / 60_000));
         this.setTopicIcon(instanceName, "red");
-        await adapter.notifyAlert(String(groupId), {
-            type: "hang",
+        await this.postNonceButtonPrompt({
+            prefix: HANG_CALLBACK_PREFIX,
+            alertType: "hang",
             instanceName,
-            message: `⚠️ ${instanceName} may be stuck — pane unchanged for ${unchangedMinutes}min, ready prompt not recognized`,
+            adapter,
+            adapterId,
+            chatId,
+            threadId,
+            message: t("hang.detected", instanceName, unchangedMinutes),
             choices: [
-                { id: `hang:restart:${instanceName}`, label: "🔄 Force restart" },
-                { id: `hang:wait:${instanceName}`, label: "⏳ Keep waiting" },
+                { action: "restart", label: t("hang.restart") },
+                { action: "wait", label: t("hang.wait") },
             ],
-        }, {
-            threadId: threadId != null ? String(threadId) : undefined,
-        }).catch(e => this.logger.warn({ err: e }, "Failed to send hang notification"));
+            expiredText: t("hang.expired", instanceName),
+        });
+    }
+    /**
+     * Consume a hang Force-restart / Keep-waiting button exactly once. Restart
+     * goes through restartSingleInstance — serialized against concurrent restart
+     * sources, and with a Classic-instance fallback (the previous hand-rolled
+     * stop+start silently left Classic instances stopped while reporting
+     * "restarted").
+     */
+    async handleHangPrompt(data, callbackAdapterId, receivingAdapter) {
+        const claimed = this.consumeNonceCallback(HANG_CALLBACK_PREFIX, /^hang:([0-9a-f]+):(restart|wait)$/, data, callbackAdapterId, receivingAdapter);
+        if (claimed === null)
+            return false;
+        if (claimed === "consumed")
+            return true;
+        const { entry: pending, action } = claimed;
+        this.eventLog?.insert(pending.instanceName, "hang_action", { action, userId: data.userId });
+        if (action === "wait") {
+            await this.retireNonceButtons(pending, pending.messageId ?? data.messageId, t("hang.waiting", pending.instanceName));
+            return true;
+        }
+        await this.retireNonceButtons(pending, pending.messageId ?? data.messageId, t("hang.restarting", pending.instanceName));
+        try {
+            await this.restartSingleInstance(pending.instanceName);
+            await pending.adapter.editMessage(pending.chatId, pending.messageId ?? data.messageId, t("hang.restarted", pending.instanceName), pending.threadId);
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            this.logger.error({ err, instanceName: pending.instanceName }, "Hang force-restart failed");
+            await pending.adapter.editMessage(pending.chatId, pending.messageId ?? data.messageId, t("hang.restart_failed", pending.instanceName, message), pending.threadId).catch(editErr => this.logger.warn({ err: editErr, instanceName: pending.instanceName }, "Failed to show hang restart error"));
+        }
+        return true;
     }
     // ── Topic icon + auto-archive ─────────────────────────────────────────────
     static INSTRUCTIONS_FILENAME = {
@@ -5129,6 +6242,10 @@ export class FleetManager {
         "gemini-cli": "GEMINI.md",
         "opencode": "AGENTS.md",
         "kiro-cli": ".kiro/steering/project.md",
+        // Grok reads AGENTS.md project docs; agy reads .agents/agents.md — the
+        // same files their writeConfig() appends fleet instructions to.
+        "grok": "AGENTS.md",
+        "antigravity": ".agents/agents.md",
         "mock": "CLAUDE.md",
     };
     static GENERAL_INSTRUCTIONS = `# Fleet Coordinator
@@ -5138,146 +6255,33 @@ You route tasks, manage instances, enforce policies, and synthesize results.
 Do NOT modify project files directly — delegate file changes to the project's instance.
 You CAN write code snippets, explain code, and answer technical questions directly.
 
------
-
-## Task Classification
-
-Classify every incoming request before acting.
-
-### Handle Directly (ALL conditions must be true)
-
-- No file system access needed
-- No external execution needed
-- Answerable from static knowledge
-- ≤ 2 reasoning steps
-
-Examples: Q&A, translation, fleet status queries, explaining a concept, writing code snippets.
-
-### Delegate to 1 Instance
-
-- Task scoped to a single project or repo
-- Requires file access, code changes, or execution
-
-### Coordinate Multiple Instances
-
-- Task spans multiple repos or domains
-- Requires outputs from one instance to feed into another
-- Benefits from parallel execution (max 3 instances per task)
-
------
-
-## Instance Discovery (in this order)
-1. list_teams()        → reuse existing teams first
-2. list_instances()    → find by working_directory, description, or tags
-3. describe_instance() → confirm capabilities before delegating
-4. create_instance()   → only if no suitable instance exists
-
-Rules: prefer reuse over creation. Do NOT create duplicates of running instances.
-
------
-
-## Delegation Protocol
-
-Every delegation via send_to_instance() MUST include:
-
-1. Task scope — what exactly to do, bounded clearly
-2. Expected output — what to return and in what form
-3. Policy reminder — "Follow Development Workflow policy" (for code tasks)
-
-### Loop Prevention
-
-- Never re-delegate a task back to the instance that sent it to you
-- If a task has bounced 3 times, stop and solve locally or reduce scope
-
-### Execution Strategy
+## Task Routing
 
-Parallel — use only when tasks are independent with no shared state
-Sequential — use when one task's output feeds into the next
+- **Handle directly**: no file/exec access needed, answerable from knowledge, ≤2 reasoning steps (Q&A, translation, status queries, code snippets).
+- **Delegate to 1 instance**: scoped to one project/repo, needs file access or execution.
+- **Coordinate multiple**: spans repos, outputs feed each other, or parallel helps (max 3 per task).
 
------
+Instance discovery order: list_teams() → list_instances() → describe_instance() → create_instance() only if nothing fits. Prefer reuse; never duplicate a running instance.
 
-## Result Handling
+## Reply Contract
 
-When an instance reports back, classify the outcome:
-
-- Success → Summarize key results for user. Omit internal coordination noise.
-- Partial → State what succeeded, what remains, proposed next steps.
-- Failure → Retry up to 2 times. If still failing: try alternative instance, reduce scope, or return partial result clearly marked.
-- No response → Ping again after reasonable wait. If still silent: report to user with options.
-
-### Output to User
-
-Every final response to the user should contain:
-
-- Result — the actual answer or deliverable
-- Gaps — anything incomplete or unresolved (omit if none)
-
------
-
-## Shared Decisions
-
-Use post_decision() / list_decisions() for any choice that affects more than 1 instance, changes an API contract, introduces a new dependency, or alters deployment process.
-
-When instances disagree, collect both viewpoints, make a decision, and record it via post_decision.
-
------
+Every final response to the user contains: the result (the actual answer or deliverable) and gaps (anything incomplete — omit if none). Summarize instance reports; omit internal coordination noise.
 
 ## After Restart
 
-After a restart, run this sequence BEFORE processing any new messages:
-1. list_instances()   → rebuild fleet awareness
-2. list_teams()       → restore team structure
-3. list_decisions()   → reload policies and conventions
-
-Only then handle incoming requests.
-
------
-
-## Development Workflow Policy
-
-All code changes across the fleet should follow this workflow.
-The coordinator enforces compliance but does not perform these steps directly.
-Remind instances of this policy when delegating code tasks.
-
-### Workflow Stages
-Design Proposed → Design Approved → Implementation → Submit for Review → Under Review → Approved → Merge
-
-### Policy Rules
+BEFORE processing any new messages: 1. list_instances() 2. list_teams() 3. list_decisions(). Only then handle requests.
 
-1. Design before code — developer sends design proposal to reviewer before implementation. Consensus required before proceeding.
-2. Challenger pairing — every code task should have a developer + reviewer. Reviewer actively questions decisions and finds risks.
-3. Verify by execution — backend/CLI changes must be tested by running them. Do not trust documentation alone.
-4. Independent review — every merge requires code review from someone other than the author.
-5. Root cause first — bug fixes require confirmed root cause before proposing a fix.
-6. Merge conditions: tests pass, reviewer approved, branch and worktree cleaned up.
+## Playbooks (on-demand skills)
 
-### Specialist Instance Rules
-
-- Execute within defined scope only
-- Return structured output: result, assumptions, uncertainties, verification status
-- Do NOT create new instances without coordinator approval
-
------
-
-## Team Management
-
-- Always check existing teams before creating new ones
-- Default to ephemeral teams (created for a specific task, dissolved after completion)
-- Clean up ephemeral teams and instances after task completion
-
------
-
-## Instance Configuration Tips
-
-When users create specialized instances, suggest these configurations:
-
-- **Reviewer instances**: Add \`pre_task_command: "/chat load reviewer-base"\` to reset context before each review, preventing influence from previous conversations.
-- **Collab mode**: For multi-bot channels, use \`/collab\` to enable @mention-based triggering.
-- **Cost control**: Set per-instance \`cost_guard\` for expensive backends.
+Detailed procedures live in your skills — consult them when the situation comes up rather than from memory:
+- **delegation-playbook** — delegation protocol, loop prevention, parallel vs sequential, result/failure handling, team management, instance configuration tips.
+- **development-workflow** — the fleet-wide code-change policy you enforce when delegating code tasks.
+Plus the operational skills (fleet-health, instance-lifecycle, scheduling, session-management, …).
 `;
     /** Ensure the general instance has its project instructions file + knowledge */
-    ensureGeneralInstructions(workDir, backendName) {
+    ensureGeneralInstructions(workDir, backendName, instanceName) {
         const backend = backendName ?? "claude-code";
+        workDir = this.resolveKnowledgeWorkDir(workDir, backend, instanceName);
         const filename = FleetManager.INSTRUCTIONS_FILENAME[backend] ?? "CLAUDE.md";
         const filePath = join(workDir, filename);
         mkdirSync(dirname(filePath), { recursive: true });
@@ -5285,60 +6289,238 @@ When users create specialized instances, suggest these configurations:
             writeFileSync(filePath, FleetManager.GENERAL_INSTRUCTIONS, "utf-8");
             this.logger.info({ filePath }, "Created general instance instructions file");
         }
-        // Sync bundled knowledge files to general's steering directory
+        // Sync bundled knowledge files to general's steering and skills directories.
         this.syncGeneralKnowledge(workDir, backend);
     }
-    /** Copy general-knowledge steering + skills to the general instance's workspace */
+    /** Resolve the workspace path a backend actually uses before publishing knowledge. */
+    resolveKnowledgeWorkDir(workDir, backend, instanceName) {
+        // Some backends relocate their real cwd (agy moves hidden paths to
+        // ~/agend-workspaces/<name>). Instructions and skills must land where the
+        // CLI actually runs, not where fleet.yaml points.
+        try {
+            const resolved = createBackend(backend, join(getAgendHome(), "cli-env"))
+                .resolveWorkingDirectory?.(workDir, instanceName);
+            if (resolved)
+                workDir = resolved;
+        }
+        catch { /* unknown backend name — keep the raw path */ }
+        return workDir;
+    }
+    /**
+     * Where each backend natively loads on-demand skills from, relative to the
+     * workspace. Backends without a native skill mechanism (opencode, grok,
+     * antigravity, gemini-cli) are deliberately absent: dropping files a CLI
+     * never reads is clutter, not capability. Unknown directories are ignored
+     * by older CLI versions, so publishing is fail-open across upgrades.
+     */
+    static SKILLS_DIR_SEGMENTS = {
+        "kiro-cli": [".kiro", "skills"],
+        "claude-code": [".claude", "skills"],
+        "codex": [".agents", "skills"],
+        // Live-verified: OpenCode and Antigravity scan .agents/skills; Grok's
+        // vendor-canonical location is .grok/skills.
+        "opencode": [".agents", "skills"],
+        "grok": [".grok", "skills"],
+        "antigravity": [".agents", "skills"],
+    };
+    /** Copy general-knowledge steering + all role-eligible skills to General. */
     syncGeneralKnowledge(workDir, backend) {
         const knowledgeDir = join(dirname(fileURLToPath(import.meta.url)), "general-knowledge");
         if (!existsSync(knowledgeDir))
             return;
-        // Sync steering files → .kiro/steering/ (or workDir root for non-kiro)
-        const steeringDir = backend === "kiro-cli"
-            ? join(workDir, ".kiro", "steering")
-            : workDir;
-        mkdirSync(steeringDir, { recursive: true });
-        const srcSteering = join(knowledgeDir, "steering");
-        if (existsSync(srcSteering)) {
-            for (const file of readdirSync(srcSteering)) {
-                if (!file.endsWith(".md"))
-                    continue;
-                const src = join(srcSteering, file);
+        this.syncGeneralSteering(workDir, backend, join(knowledgeDir, "steering"));
+        this.syncRoleSkills(workDir, backend, "general", knowledgeDir);
+        this.logger.debug({ knowledgeDir, workDir, backend }, "Synced general knowledge files");
+    }
+    /** Publish only the bundled skills eligible for an instance role. */
+    syncRoleSkills(workDir, backend, role, knowledgeDir) {
+        const skillSegments = FleetManager.SKILLS_DIR_SEGMENTS[backend];
+        if (!skillSegments)
+            return;
+        const root = knowledgeDir ?? join(dirname(fileURLToPath(import.meta.url)), "general-knowledge");
+        if (!existsSync(root))
+            return;
+        // Before managed-skill manifests existed, only Kiro General received
+        // bundled skills. Allow that one legacy layout to be adopted so upgrades
+        // can keep those copies current; other backends never had unmanaged
+        // AgEnD-published skills and must retain the normal user-ownership guard.
+        const adoptLegacyUnmanaged = backend === "kiro-cli" && role === "general";
+        this.syncManagedSkills(join(workDir, ...skillSegments), join(root, "skills"), role, adoptLegacyUnmanaged);
+        this.logger.debug({ workDir, backend, role }, "Synced role-based bundled skills");
+    }
+    /**
+     * Steering (always-on rules like core-rules.md). Kiro loads a native
+     * steering directory; every other backend gets the content embedded into
+     * its instructions file (CLAUDE.md / AGENTS.md / …) inside a managed marker
+     * block — the previous behavior dropped bare .md files in the workspace
+     * root, which no CLI ever read. The block is replaced in place on every
+     * sync, so rule updates reach EXISTING workspaces; everything the user
+     * wrote outside the markers is preserved byte-for-byte.
+     */
+    syncGeneralSteering(workDir, backend, srcSteering) {
+        if (!existsSync(srcSteering))
+            return;
+        const files = readdirSync(srcSteering).filter(f => f.endsWith(".md")).sort();
+        if (files.length === 0)
+            return;
+        if (backend === "kiro-cli") {
+            const steeringDir = join(workDir, ".kiro", "steering");
+            mkdirSync(steeringDir, { recursive: true });
+            for (const file of files) {
                 const dest = join(steeringDir, file);
-                const newContent = readFileSync(src, "utf-8");
+                const newContent = readFileSync(join(srcSteering, file), "utf-8");
                 try {
                     if (existsSync(dest) && readFileSync(dest, "utf-8") === newContent)
                         continue;
                 }
-                catch { }
+                catch { /* rewrite */ }
                 writeFileSync(dest, newContent);
             }
+            return;
         }
-        // Sync skills → .kiro/skills/ (kiro-cli only)
-        if (backend === "kiro-cli") {
-            const srcSkills = join(knowledgeDir, "skills");
-            if (existsSync(srcSkills)) {
-                const destSkills = join(workDir, ".kiro", "skills");
-                mkdirSync(destSkills, { recursive: true });
-                for (const skillDir of readdirSync(srcSkills)) {
-                    const skillSrc = join(srcSkills, skillDir);
-                    if (!existsSync(join(skillSrc, "SKILL.md")))
-                        continue;
-                    const skillDest = join(destSkills, skillDir);
-                    mkdirSync(skillDest, { recursive: true });
-                    const src = join(skillSrc, "SKILL.md");
-                    const dest = join(skillDest, "SKILL.md");
-                    const newContent = readFileSync(src, "utf-8");
-                    try {
-                        if (existsSync(dest) && readFileSync(dest, "utf-8") === newContent)
-                            continue;
-                    }
-                    catch { }
-                    writeFileSync(dest, newContent);
-                }
+        const filename = FleetManager.INSTRUCTIONS_FILENAME[backend] ?? "CLAUDE.md";
+        const instructionsPath = join(workDir, filename);
+        const body = files.map(f => readFileSync(join(srcSteering, f), "utf-8").trim()).join("\n\n");
+        const block = `${FleetManager.STEERING_BLOCK_BEGIN}\n${body}\n${FleetManager.STEERING_BLOCK_END}`;
+        let existing = "";
+        try {
+            existing = existsSync(instructionsPath) ? readFileSync(instructionsPath, "utf-8") : "";
+        }
+        catch { /* treat as empty */ }
+        const beginAt = existing.indexOf(FleetManager.STEERING_BLOCK_BEGIN);
+        const endAt = existing.indexOf(FleetManager.STEERING_BLOCK_END);
+        let next;
+        if (beginAt !== -1 && endAt !== -1 && endAt > beginAt) {
+            next = existing.slice(0, beginAt) + block + existing.slice(endAt + FleetManager.STEERING_BLOCK_END.length);
+        }
+        else {
+            next = existing.trimEnd() + (existing.trim() ? "\n\n" : "") + block + "\n";
+        }
+        if (next !== existing) {
+            mkdirSync(dirname(instructionsPath), { recursive: true });
+            writeFileSync(instructionsPath, next);
+        }
+    }
+    static STEERING_BLOCK_BEGIN = "<!-- >>> agend:core-rules — managed by AgEnD; edits inside this block are overwritten -->";
+    static STEERING_BLOCK_END = "<!-- <<< agend:core-rules -->";
+    /**
+     * Publish AgEnD's bundled skills into a CLI's native skills directory,
+     * owning ONLY what we published. A manifest records which skill names AgEnD
+     * wrote; a bundled rename/removal deletes the stale managed copy, while a
+     * skill the user created by hand is never listed and therefore never
+     * touched — even if a future bundle happens to reuse its name (the sync
+     * then skips it and logs, rather than overwrite the user's work). The sole
+     * migration exception is the pre-manifest Kiro General layout explicitly
+     * selected by adoptLegacyUnmanaged.
+     */
+    syncManagedSkills(destSkills, srcSkills, role, adoptLegacyUnmanaged = false) {
+        if (!existsSync(srcSkills))
+            return;
+        mkdirSync(destSkills, { recursive: true });
+        const manifestPath = join(destSkills, ".agend-managed-skills.json");
+        const hadManifest = existsSync(manifestPath);
+        let previouslyManaged = [];
+        try {
+            const parsed = JSON.parse(readFileSync(manifestPath, "utf-8"));
+            if (Array.isArray(parsed))
+                previouslyManaged = parsed.filter(n => typeof n === "string");
+        }
+        catch { /* first sync, or corrupt manifest — treat as owning nothing */ }
+        const bundled = readdirSync(srcSkills)
+            .filter(name => existsSync(join(srcSkills, name, "SKILL.md")))
+            .sort();
+        // Pre-manifest Kiro General copied bundled skills directly into
+        // .kiro/skills. If every existing skill is still a bundled name, this is
+        // the unambiguous legacy layout: adopt it once, update it below, and write
+        // the ownership manifest. Any extra skill name keeps the directory fully
+        // on the user-owned/collision path.
+        if (!hadManifest && adoptLegacyUnmanaged) {
+            const existing = readdirSync(destSkills, { withFileTypes: true })
+                .filter(entry => entry.isDirectory() && existsSync(join(destSkills, entry.name, "SKILL.md")))
+                .map(entry => entry.name)
+                .sort();
+            if (existing.length > 0 && existing.every(name => bundled.includes(name))) {
+                previouslyManaged = existing;
+                this.logger.info({ skills: existing, destSkills }, "Adopted legacy AgEnD skills into managed ownership");
+            }
+        }
+        const eligible = bundled.filter(name => {
+            const roles = this.readManagedSkillRoles(join(srcSkills, name, "SKILL.md"));
+            // General is the coordinator and receives both coordinator and worker
+            // playbooks. Workers receive only skills explicitly marked for workers.
+            return role === "general" || roles.includes("worker");
+        });
+        const managed = [];
+        for (const name of eligible) {
+            const destDir = join(destSkills, name);
+            const dest = join(destDir, "SKILL.md");
+            const isOurs = previouslyManaged.includes(name) || !existsSync(destDir);
+            if (!isOurs) {
+                // Name collision with a user-authored skill: theirs wins, loudly.
+                this.logger.warn({ skill: name, destSkills }, "Skipping bundled skill — a skill of this name exists but was not published by AgEnD");
+                continue;
+            }
+            managed.push(name);
+            const newContent = readFileSync(join(srcSkills, name, "SKILL.md"), "utf-8");
+            try {
+                if (existsSync(dest) && readFileSync(dest, "utf-8") === newContent)
+                    continue;
+            }
+            catch { /* rewrite */ }
+            mkdirSync(destDir, { recursive: true });
+            writeFileSync(dest, newContent);
+        }
+        // Remove managed skills that are no longer bundled OR no longer eligible
+        // for this role. This makes a shared → general-only metadata change take
+        // effect on the next worker startup instead of leaving stale capability.
+        for (const stale of previouslyManaged) {
+            if (eligible.includes(stale))
+                continue;
+            try {
+                rmSync(join(destSkills, stale), { recursive: true, force: true });
+                this.logger.info({ skill: stale, destSkills }, "Removed retired AgEnD-managed skill");
+            }
+            catch (err) {
+                this.logger.debug({ err, skill: stale }, "Failed to remove retired managed skill");
             }
         }
-        this.logger.debug({ knowledgeDir, steeringDir }, "Synced general knowledge files");
+        try {
+            writeFileSync(manifestPath, JSON.stringify(managed, null, 2) + "\n");
+        }
+        catch (err) {
+            this.logger.debug({ err, manifestPath }, "Failed to write managed-skills manifest");
+        }
+    }
+    /** Read AgEnD's roles extension from SKILL.md YAML frontmatter. */
+    readManagedSkillRoles(skillPath) {
+        const fallback = ["general"];
+        try {
+            const content = readFileSync(skillPath, "utf-8");
+            const match = content.match(/^---[ \t]*\r?\n([\s\S]*?)\r?\n---(?:\r?\n|$)/);
+            if (!match)
+                return fallback;
+            const document = parseDocument(match[1]);
+            if (document.errors.length > 0)
+                throw document.errors[0];
+            const frontmatter = document.toJS();
+            if (!frontmatter || frontmatter.roles === undefined)
+                return fallback;
+            if (!Array.isArray(frontmatter.roles))
+                throw new Error("roles must be an array");
+            const roles = [...new Set(frontmatter.roles)]
+                .filter((value) => value === "general" || value === "worker");
+            if (roles.length !== frontmatter.roles.length || roles.length === 0) {
+                throw new Error("roles must contain only general and/or worker");
+            }
+            return roles;
+        }
+        catch (err) {
+            // Fail closed for workers: malformed or unknown metadata keeps the
+            // backwards-compatible General-only behavior instead of leaking an
+            // administrative skill into worker workspaces.
+            this.logger.warn({ err, skillPath }, "Invalid bundled skill roles — defaulting to General only");
+            return fallback;
+        }
     }
     /** Fetch forum topic icon stickers and pick emoji IDs for each state */
     async resolveTopicIcons() {
@@ -5770,6 +6952,17 @@ When users create specialized instances, suggest these configurations:
                 return null;
             const probed = await be.probeCLIEnv({ workingDirectory: "", instanceDir: join(getAgendHome(), "cli-env"), instanceName: `probe-${backend}`, mcpServers: {} });
             const env = { backend, probedAt: Date.now(), ...probed };
+            // An empty result must never overwrite a catalog we already have. Some
+            // probes hit the network (`agy models` fetches, 5s cap), so a slow moment
+            // returns [] — and writing that would blank the list for the whole 24h
+            // TTL, long after the CLI recovered. Observed live: a good 11-model
+            // antigravity cache replaced by an empty one. Keep the known models and
+            // let the fresher currentModel/version through.
+            if (!env.models?.length) {
+                const previous = this.readCliEnv(backend);
+                if (previous?.models?.length)
+                    env.models = previous.models;
+            }
             const path = this.cliEnvPath(backend);
             mkdirSync(dirname(path), { recursive: true });
             writeFileSync(path, JSON.stringify(env, null, 2));
@@ -5808,6 +7001,108 @@ When users create specialized instances, suggest these configurations:
         const env = await this.probeBackend(backendName);
         return env?.models ?? [];
     }
+    /**
+     * Model catalog behind the `list_models` tool.
+     *
+     * The two scopes are not cosmetic. "global" is the account/CLI catalog served
+     * from the startup probe cache; "instance" is resolved through that instance's
+     * OWN backend config, and for a Codex instance on a custom provider that is a
+     * different catalog entirely — `listModels()` reads models_cache.json out of
+     * the instance's private CODEX_HOME. Answering such an instance with the
+     * account list would name models its CLI rejects, which is exactly the
+     * mistake this tool exists to prevent.
+     *
+     * `scope` always describes where the returned LIST came from, not what was
+     * asked for: an instance query that falls back to the account catalog reports
+     * scope "global" and says so in `note`, rather than implying instance-level
+     * accuracy it does not have.
+     *
+     * Never throws — a model listing is an aid, and failing it must not fail a turn.
+     */
+    async listModelCatalog(opts = {}) {
+        const { instanceName } = opts;
+        if (instanceName) {
+            const backend = this.backendNameForInstance(instanceName);
+            const resolved = this.resolveInstanceModel(instanceName);
+            const currentModel = resolved.source === "unresolved" ? null : resolved.model;
+            const provider = this.customProviderFor(instanceName, backend);
+            const scoped = await this.instanceScopedModels(instanceName, backend);
+            if (scoped.length) {
+                return {
+                    backend, scope: "instance", instance: instanceName,
+                    current_model: currentModel, models: scoped, source: "live",
+                    ...(provider ? { note: `Catalog read through this instance's ${backend} provider "${provider}" — it may differ from the account catalog.` } : {}),
+                };
+            }
+            // No instance-local catalog (never launched, or the backend has no
+            // per-instance list). The account catalog is the best available answer,
+            // but it is labelled honestly rather than dressed up as instance scope.
+            const global = await this.globalModelCatalog(backend);
+            return {
+                ...global, instance: instanceName, current_model: currentModel,
+                note: provider
+                    ? `No instance-local catalog yet; showing the account catalog, which may NOT match this instance's ${backend} provider "${provider}".`
+                    : "No instance-local catalog yet; showing the account catalog.",
+            };
+        }
+        return this.globalModelCatalog(opts.backend ?? this.fleetConfig?.defaults?.backend ?? "claude-code");
+    }
+    /** The custom provider an instance overrides its backend with, if any. */
+    customProviderFor(instanceName, backend) {
+        const opts = this.fleetConfig?.instances?.[instanceName]?.backend_options?.[backend]
+            ?? this.fleetConfig?.defaults?.backend_options?.[backend];
+        const provider = opts?.provider;
+        return typeof provider === "string" && provider.trim() ? provider.trim() : null;
+    }
+    /** Ask a backend for its catalog using ONE instance's real config. Never throws. */
+    async instanceScopedModels(instanceName, backend) {
+        try {
+            const inst = this.fleetConfig?.instances?.[instanceName];
+            const instanceDir = this.getInstanceDir(instanceName);
+            const be = createBackend(backend, instanceDir);
+            if (!be.listModels)
+                return [];
+            return await be.listModels({
+                workingDirectory: inst?.working_directory ?? "",
+                instanceDir,
+                instanceName,
+                mcpServers: {},
+                model: inst?.model,
+                backendOptions: inst?.backend_options?.[backend] ?? this.fleetConfig?.defaults?.backend_options?.[backend],
+            }) ?? [];
+        }
+        catch {
+            // listModels is documented never to throw, but a backend constructor can
+            // (missing binary). A catalog is an aid; degrade to the account list.
+            return [];
+        }
+    }
+    /** Account-wide catalog: probe cache first, live probe on miss. */
+    async globalModelCatalog(backend) {
+        const cached = this.readCliEnv(backend);
+        if (cached?.models?.length) {
+            return {
+                backend, scope: "global", current_model: cached.currentModel ?? null,
+                models: cached.models, source: "cache",
+                probed_at: new Date(cached.probedAt).toISOString(),
+            };
+        }
+        const env = await this.probeBackend(backend);
+        if (env?.models?.length) {
+            return {
+                backend, scope: "global", current_model: env.currentModel ?? null,
+                models: env.models, source: "live",
+                probed_at: new Date(env.probedAt).toISOString(),
+            };
+        }
+        // Reported rather than thrown: "we could not enumerate" is a useful answer,
+        // and the caller can still set a model by name (AgEnD passes it through).
+        return {
+            backend, scope: "global", current_model: env?.currentModel ?? null,
+            models: [], source: "fallback",
+            note: `Could not enumerate models for ${backend} (CLI missing, not logged in, or it offers no list). Model names are passed through to the CLI, so a known-good name still works.`,
+        };
+    }
     /** `/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) {
@@ -5816,10 +7111,10 @@ When users create specialized instances, suggest these configurations:
     effortMenuHeader(instanceName) {
         const { effort, source } = this.resolveInstanceEffort(instanceName);
         if (!effort)
-            return "Current effort: (CLI default)";
+            return t("effort.current_default");
         return source === "fleet-default"
-            ? `Current effort: ${effort} (fleet default)`
-            : `Current effort: ${effort}`;
+            ? t("effort.current_fleet", effort)
+            : t("effort.current", effort);
     }
     /** `/effort` — DC Select Menu, or apply directly when a level is given. */
     async handleEffortSlash(data, adapterId) {
@@ -5840,11 +7135,11 @@ When users create specialized instances, suggest these configurations:
         }
         const levels = this.effortLevelsFor(name);
         if (levels.length === 0) {
-            await data.respond(`❌ ${this.backendNameForInstance(name)} has no reasoning-effort setting.`);
+            await data.respond(t("effort.unsupported", this.backendNameForInstance(name)));
             return;
         }
         if (!data.respondChoices) {
-            await data.respond(`Usage: /effort <${levels.join("|")}>`);
+            await data.respond(t("effort.usage", levels.join("|")));
             return;
         }
         const current = this.resolveInstanceEffort(name).effort;
@@ -5857,20 +7152,20 @@ When users create specialized instances, suggest these configurations:
         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);
+            await data.respondChoices(t("effort.menu", this.effortMenuHeader(name)), 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("|")}>`);
+            await data.respond(t("effort.usage", 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.`;
+            return t("effort.unsupported", this.backendNameForInstance(instanceName));
         }
         const current = this.resolveInstanceEffort(instanceName).effort;
         const nonce = randomBytes(6).toString("hex");
@@ -5886,13 +7181,13 @@ When users create specialized instances, suggest these configurations:
             const p = this.pendingEffortSelects.get(nonce);
             if (p) {
                 this.pendingEffortSelects.delete(nonce);
-                p.respond("⏰ Effort selection expired.").catch(() => { });
+                p.respond(t("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 menuMessageId = await adapter.promptUser(chatId, t("effort.menu", this.effortMenuHeader(instanceName)), choices, { threadId });
             const pending = this.pendingEffortSelects.get(nonce);
             if (pending)
                 pending.menuMessageId = menuMessageId;
@@ -5902,7 +7197,7 @@ When users create specialized instances, suggest these configurations:
             this.pendingEffortSelects.delete(nonce);
             clearTimeout(timer);
             this.logger.warn({ err, instanceName }, "TG effort menu failed");
-            return `Usage: /effort <${levels.join("|")}>`;
+            return t("effort.usage", levels.join("|"));
         }
     }
     /** Consume an `/effort` selection callback. Mirrors handleModelSelection. */
@@ -5923,7 +7218,7 @@ When users create specialized instances, suggest these configurations:
         this.pendingEffortSelects.delete(match[1]);
         clearTimeout(pending.timer);
         const level = match[2];
-        const progressText = `⏳ Setting ${pending.instanceName} effort to \`${level}\`…`;
+        const progressText = t("effort.setting", pending.instanceName, level);
         let progressMsgId;
         if (pending.adapter && pending.adapterChatId) {
             const menuMessageId = pending.menuMessageId ?? data.messageId;
@@ -5955,7 +7250,7 @@ When users create specialized instances, suggest these configurations:
             }
             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)}`;
+                result = t("effort.switch_failed", level, err instanceof Error ? err.message : String(err));
             }
             if (pending.adapter && pending.adapterChatId) {
                 if (progressMsgId) {
@@ -5992,12 +7287,12 @@ When users create specialized instances, suggest these configurations:
         }
         // No arg (or --refresh) → menu. Menu is DC-only this round (respondChoices); TG uses `/model <name>`.
         if (!data.respondChoices) {
-            await data.respond("Usage: /model <name> — e.g. /model sonnet");
+            await data.respond(t("model.usage"));
             return;
         }
         const options = await this.getModelOptions(name, isRefresh);
         if (options.length === 0) {
-            await data.respond(`No model list available for ${name}. Type \`/model <name>\` to set one directly.`);
+            await data.respond(t("model.list_unavailable", name));
             return;
         }
         // Raw id for ✓-matching options; display resolves an inherited CLI default.
@@ -6011,13 +7306,13 @@ When users create specialized instances, suggest these configurations:
         timer.unref?.();
         this.pendingModelSelects.set(nonce, { instanceName: name, model: "", userId: data.userId, channelId: data.channelId, timer, respond: data.respond });
         try {
-            await data.respondChoices(`Current model: **${currentDisplay}**\nSelect a new model:`, choices);
+            await data.respondChoices(t("model.menu", `**${currentDisplay}**`), choices);
         }
         catch (err) {
             this.pendingModelSelects.delete(nonce);
             clearTimeout(timer);
             this.logger.warn({ err, instanceName: name }, "model menu failed");
-            await data.respond("Usage: /model <name> — e.g. /model sonnet");
+            await data.respond(t("model.usage"));
         }
     }
     /**
@@ -6028,7 +7323,7 @@ When users create specialized instances, suggest these configurations:
     async promptModelMenu(instanceName, userId, channelId, adapter, chatId, threadId) {
         const options = await this.getModelOptions(instanceName);
         if (options.length === 0) {
-            return `No model list available for ${instanceName}. Use \`/model <name>\` to set one directly.`;
+            return t("model.list_unavailable", instanceName);
         }
         const { model: currentModel, display: currentDisplay } = this.resolveInstanceModel(instanceName);
         const nonce = randomBytes(6).toString("hex");
@@ -6044,13 +7339,13 @@ When users create specialized instances, suggest these configurations:
             const p = this.pendingModelSelects.get(nonce);
             if (p) {
                 this.pendingModelSelects.delete(nonce);
-                p.respond("⏰ Model selection expired.").catch(() => { });
+                p.respond(t("model.selection_expired")).catch(() => { });
             }
         }, CLASSIC_BACKEND_SELECTION_TIMEOUT_MS);
         timer.unref?.();
         this.pendingModelSelects.set(nonce, { instanceName, model: "", userId, channelId, timer, respond, adapter, adapterChatId: chatId, adapterThreadId: threadId });
         try {
-            const menuMessageId = await adapter.promptUser(chatId, `Current model: ${currentDisplay}\nSelect a new model:`, choices, { threadId });
+            const menuMessageId = await adapter.promptUser(chatId, t("model.menu", currentDisplay), choices, { threadId });
             const pending = this.pendingModelSelects.get(nonce);
             if (pending)
                 pending.menuMessageId = menuMessageId;
@@ -6060,7 +7355,7 @@ When users create specialized instances, suggest these configurations:
             this.pendingModelSelects.delete(nonce);
             clearTimeout(timer);
             this.logger.warn({ err, instanceName }, "TG model menu failed");
-            return `Usage: /model <name> — e.g. /model sonnet`;
+            return t("model.usage");
         }
     }
     /** Consume a `/model` selection callback. Returns true for all model-select ids (incl. stale). */
@@ -6083,7 +7378,7 @@ When users create specialized instances, suggest these configurations:
         clearTimeout(pending.timer);
         const model = match[2];
         // Send immediate "⏳ Switching..." feedback, then apply in background.
-        const progressText = `⏳ Switching ${pending.instanceName} to \`${model}\`…`;
+        const progressText = t("model.switching", pending.instanceName, model);
         let progressMsgId;
         if (pending.adapter && pending.adapterChatId) {
             // TG path: turn the original menu into the progress message. This both
@@ -6120,7 +7415,7 @@ When users create specialized instances, suggest these configurations:
             }
             catch (err) {
                 this.logger.error({ err, instance: pending.instanceName, model }, "Model switch failed");
-                result = `Model switch to \`${model}\` failed: ${err instanceof Error ? err.message : String(err)}`;
+                result = t("model.switch_failed", model, err instanceof Error ? err.message : String(err));
             }
             if (pending.adapter && pending.adapterChatId) {
                 if (progressMsgId) {
@@ -6217,17 +7512,17 @@ When users create specialized instances, suggest these configurations:
         }
         catch { /* treated as unsupported below */ }
         if (strategy === "unsupported" || supported.length === 0) {
-            return `❌ ${backendName} has no reasoning-effort setting.`;
+            return t("effort.unsupported", backendName);
         }
         if (!FleetManager.EFFORT_LEVELS.includes(level)) {
-            return `❌ Unknown effort level \`${level}\`. Use: ${FleetManager.EFFORT_LEVELS.join(", ")}.`;
+            return t("effort.unknown", level, FleetManager.EFFORT_LEVELS.join(", "));
         }
         const applied = FleetManager.clampEffort(level, supported);
         if (!applied)
-            return `❌ ${backendName} accepts none of the canonical effort levels.`;
+            return t("effort.no_canonical", backendName);
         const warn = applied === level
             ? ""
-            : `⚠️ Clamped to \`${applied}\` (\`${level}\` not supported by ${backendName}).\n`;
+            : t("effort.clamped", applied, level, backendName);
         // Persist either way: a runtime switch must survive the next respawn too,
         // or the instance silently reverts on restart.
         if (this.fleetConfig?.instances[instanceName]) {
@@ -6236,12 +7531,12 @@ When users create specialized instances, suggest these configurations:
         }
         if (strategy === "runtime") {
             if (!this.instanceIpcClients.get(instanceName))
-                return `${warn}❌ ${instanceName} is not running.`;
+                return `${warn}${t("effort.not_running", instanceName)}`;
             this.pasteRawToClassicInstance(instanceName, `/effort ${applied}`);
-            return `${warn}✅ Set ${instanceName} effort to \`${applied}\` (runtime).`;
+            return `${warn}${t("effort.runtime_success", instanceName, applied)}`;
         }
         await this.restartSingleInstance(instanceName);
-        return `${warn}✅ Set ${instanceName} effort to \`${applied}\` and restarted.`;
+        return `${warn}${t("effort.restart_success", instanceName, applied)}`;
     }
     async applyModel(instanceName, model) {
         const backendName = this.backendNameForInstance(instanceName);
@@ -6250,14 +7545,12 @@ When users create specialized instances, suggest these configurations:
             strategy = createBackend(backendName, this.getInstanceDir(instanceName)).getModelSwitchStrategy?.(model) ?? "restart";
         }
         catch { /* default restart */ }
-        const warn = isModelCompatible(backendName, model) ? "" : `⚠️ "${model}" doesn't match ${backendName}'s usual pattern — passing through anyway.\n`;
-        if (strategy === "runtime") {
-            if (!this.instanceIpcClients.get(instanceName))
-                return `${warn}❌ ${instanceName} is not running.`;
-            this.pasteRawToClassicInstance(instanceName, `/model ${model}`);
-            return `${warn}✅ Switched ${instanceName} to \`${model}\` (runtime).${this.effortSuffix(instanceName)}`;
+        const warn = isModelCompatible(backendName, model) ? "" : t("model.pattern_warning", model, backendName);
+        if (strategy === "runtime" && !this.instanceIpcClients.get(instanceName)) {
+            return `${warn}${t("effort.not_running", instanceName)}`;
         }
-        // restart: persist the model so the respawned CLI launches with it.
+        // Persist either way: a runtime switch must survive the next respawn too,
+        // or the instance silently reverts to the CLI default after a fleet restart.
         let persisted = false;
         if (this.fleetConfig?.instances[instanceName]) {
             this.fleetConfig.instances[instanceName].model = model;
@@ -6268,9 +7561,13 @@ When users create specialized instances, suggest these configurations:
             persisted = true;
         }
         if (!persisted)
-            return `${warn}❌ Could not set model for ${instanceName}.`;
+            return `${warn}${t("model.persist_failed", instanceName)}`;
+        if (strategy === "runtime") {
+            this.pasteRawToClassicInstance(instanceName, `/model ${model}`);
+            return `${warn}${t("model.runtime_success", instanceName, model)}${this.effortSuffix(instanceName)}`;
+        }
         await this.restartSingleInstance(instanceName);
-        return `${warn}✅ Set ${instanceName} to \`${model}\` and restarted.${this.effortSuffix(instanceName)}`;
+        return `${warn}${t("model.restart_success", instanceName, model)}${this.effortSuffix(instanceName)}`;
     }
     /**
      * The trailing "Current effort: …" line for a /model reply.
@@ -6284,10 +7581,10 @@ When users create specialized instances, suggest these configurations:
             return "";
         const { effort, source } = this.resolveInstanceEffort(instanceName);
         if (!effort)
-            return "\nCurrent effort: (CLI default)";
+            return `\n${t("effort.current_default")}`;
         return source === "fleet-default"
-            ? `\nCurrent effort: ${effort} (fleet default)`
-            : `\nCurrent effort: ${effort}`;
+            ? `\n${t("effort.current_fleet", effort)}`
+            : `\n${t("effort.current", effort)}`;
     }
     /** Read recent chat log for agent context */
     getRecentChatLog(instanceName, maxLines = 10) {
@@ -6322,7 +7619,7 @@ When users create specialized instances, suggest these configurations:
     /** Return a user-facing blocker without mutating ClassicBot state. */
     validateClassicStart(channelId, userId, guildId, adapterId) {
         if (!this.classicChannels)
-            return "Classic channel manager not initialized.";
+            return t("classic.manager_unavailable");
         if (guildId && !this.classicChannels.isGuildAllowed(guildId)) {
             const generalId = this.findGeneralInstance(adapterId);
             if (generalId)
@@ -6469,6 +7766,7 @@ When users create specialized instances, suggest these configurations:
             return;
         const workDir = join(getAgendHome(), "workspaces", instanceName);
         ensureWorkspaceGit(workDir);
+        const classicIdentity = this.classicChannels?.getAll().find(ch => ch.instanceName === instanceName);
         const config = {
             ...DEFAULT_INSTANCE_CONFIG,
             ...this.fleetConfig?.defaults,
@@ -6476,6 +7774,8 @@ When users create specialized instances, suggest these configurations:
             lightweight: true,
             ...(backend ? { backend } : {}),
             ...(model ? { model } : {}),
+            ...(classicIdentity?.displayName ? { display_name: classicIdentity.displayName } : {}),
+            ...(classicIdentity?.description ? { description: classicIdentity.description } : {}),
             ...(autoPauseAfter !== undefined ? { auto_pause_after: autoPauseAfter } : {}),
             ...(preTaskCommand ? { pre_task_command: preTaskCommand } : {}),
         };
@@ -6489,7 +7789,7 @@ When users create specialized instances, suggest these configurations:
             return blocker;
         const classicChannels = this.classicChannels;
         if (!classicChannels)
-            return "Classic channel manager not initialized.";
+            return t("classic.manager_unavailable");
         const instanceName = classicChannels.deriveInstanceName(channelName || channelId, channelId, adapterId);
         clearPausedMarker(this.getInstanceDir(instanceName));
         const selectedBackend = isSelectableClassicBackend(backend) ? backend : undefined;
@@ -6511,7 +7811,7 @@ When users create specialized instances, suggest these configurations:
     /** Handle /stop slash command — unregister classic channel */
     async handleClassicStop(channelId, adapterId) {
         if (!this.classicChannels)
-            return "Classic channel manager not initialized.";
+            return t("classic.manager_unavailable");
         const ch = this.classicChannels.unregister(channelId, adapterId);
         if (!ch)
             return t("classic.no_agent");
@@ -6558,6 +7858,8 @@ When users create specialized instances, suggest these configurations:
         this.clearStatuslineWatchers();
         this.costGuard?.stop();
         this.dailySummary?.stop();
+        this.dailyTipScheduler?.stop();
+        this.dailyTipScheduler = null;
         if (this.updateCheckTimer) {
             clearTimeout(this.updateCheckTimer);
             clearInterval(this.updateCheckTimer);
@@ -6606,11 +7908,11 @@ When users create specialized instances, suggest these configurations:
         for (const pending of this.pendingClassicStarts.values())
             clearTimeout(pending.timer);
         this.pendingClassicStarts.clear();
-        for (const pending of this.pendingInteractivePromptAssists.values()) {
+        for (const pending of this.pendingNonceButtons.values()) {
             if (pending.timer)
                 clearTimeout(pending.timer);
         }
-        this.pendingInteractivePromptAssists.clear();
+        this.pendingNonceButtons.clear();
         this.topicArchiver.stop();
         this.scheduler?.shutdown();
         // Stop instances in parallel batches to avoid long sequential waits.
@@ -6775,7 +8077,8 @@ When users create specialized instances, suggest these configurations:
     /**
      * Hot-reload: re-read fleet.yaml and reconcile running instances.
      * Starts new, stops removed, restarts modified instances.
-     * Fleet-level config (access, cost_guard, etc.) requires /restart to take effect.
+     * Whitelisted runtime fields are pushed into live daemons; all other instance
+     * fields, plus cold fleet-level settings, retain restart semantics.
      */
     async reconcileInstances() {
         if (!this.configPath)
@@ -6817,11 +8120,11 @@ When users create specialized instances, suggest these configurations:
             // possible outcome: they change fleet.yaml, send SIGHUP, and nothing happens
             // with no explanation anywhere they are looking.
             const why = !validation.valid
-                ? `validation failed:\n${validation.errors.map(e => `• ${e.path}: ${e.message}`).join("\n")}`
+                ? t("fleet.reload_validation", validation.errors.map(e => `• ${e.path}: ${e.message}`).join("\n"))
                 : unsafeEmpty
-                    ? `it removed every instance (${oldCount} → 0)`
-                    : `it removed more than half the instances (${oldCount} → ${newCount})`;
-            this.notifyFleetError(`⚠️ fleet.yaml reload REJECTED — ${why}\nThe previous configuration is still running.`);
+                    ? t("fleet.reload_removed_all", oldCount)
+                    : t("fleet.reload_removed_half", oldCount, newCount);
+            this.notifyFleetError(t("fleet.reload_rejected", why));
             return;
         }
         this.routing.rebuild(this.fleetConfig);
@@ -6829,9 +8132,20 @@ When users create specialized instances, suggest these configurations:
         this.scheduler?.reload();
         const newInstances = this.fleetConfig.instances;
         const topicMode = this.fleetConfig?.channel?.mode === "topic";
-        // Detect fleet-level config changes and warn
-        const oldFleetLevel = JSON.stringify({ channel: oldConfig?.channel, defaults: oldConfig?.defaults });
-        const newFleetLevel = JSON.stringify({ channel: this.fleetConfig?.channel, defaults: this.fleetConfig?.defaults });
+        // Detect fleet-level changes which still need a restart. Hot defaults are
+        // reconciled below and must not produce a misleading restart warning.
+        const oldDefaultColdWithFleetFields = oldConfig?.defaults
+            ? splitHotColdConfig(oldConfig.defaults).cold
+            : {};
+        const newDefaultColdWithFleetFields = this.fleetConfig?.defaults
+            ? splitHotColdConfig(this.fleetConfig.defaults).cold
+            : {};
+        // `tips` is a fleet-owned hot switch; it is read at post time and never
+        // belongs in a daemon config or a "restart required" warning.
+        const { tips: _oldTips, ...oldDefaultCold } = oldDefaultColdWithFleetFields;
+        const { tips: _newTips, ...newDefaultCold } = newDefaultColdWithFleetFields;
+        const oldFleetLevel = JSON.stringify({ channel: oldConfig?.channel, defaults: oldDefaultCold });
+        const newFleetLevel = JSON.stringify({ channel: this.fleetConfig?.channel, defaults: newDefaultCold });
         if (oldFleetLevel !== newFleetLevel) {
             this.logger.warn("Fleet-level config changed (channel/defaults) — use /restart for full effect");
         }
@@ -6843,7 +8157,9 @@ When users create specialized instances, suggest these configurations:
                 await this.stopInstance(name).catch(err => this.logger.error({ err, name }, "Failed to stop removed instance"));
             }
         }
-        // Start new + restart modified instances
+        // Start new + reconcile modified instances. Hot values are always sent as a
+        // complete snapshot: Settings mutates FleetManager's config before SIGHUP,
+        // so an old/new diff alone can miss the live daemon's stale value.
         for (const [name, config] of Object.entries(newInstances)) {
             if (!this.daemons.has(name)) {
                 // New instance — startInstance already calls connectIpcToInstance
@@ -6851,14 +8167,33 @@ When users create specialized instances, suggest these configurations:
                 await this.startInstance(name, config, topicMode).catch(err => this.logger.error({ err, name }, "Failed to start new instance"));
             }
             else if (oldConfig?.instances[name]) {
-                // Restart if any config field changed
-                if (JSON.stringify(oldConfig.instances[name]) !== JSON.stringify(config)) {
+                const daemon = this.daemons.get(name);
+                const runtimeConfig = daemon.getConfigSnapshot?.() ?? oldConfig.instances[name];
+                const oldParts = splitHotColdConfig(runtimeConfig);
+                const newParts = splitHotColdConfig(config);
+                // Every field not explicitly classified hot is cold by default.
+                if (!isDeepStrictEqual(oldParts.cold, newParts.cold)) {
                     this.logger.info({ name }, "Instance config changed — restarting");
                     await this.stopInstance(name).catch(() => { });
                     await this.startInstance(name, config, topicMode).catch(err => this.logger.error({ err, name }, "Failed to restart modified instance"));
                 }
+                else if (!isDeepStrictEqual(oldParts.hot, newParts.hot)) {
+                    const update = hotConfigUpdate(config);
+                    const ipc = this.instanceIpcClients.get(name);
+                    const sent = ipc?.connected === true && ipc.send({ type: "config_update", config: update });
+                    if (!sent) {
+                        // Daemon is in-process, so a reconnect gap must not leave runtime
+                        // state stale. Normal operation still uses the explicit IPC contract.
+                        daemon.applyConfigUpdate(update);
+                        this.logger.warn({ name }, "Config-update IPC unavailable — applied hot config in-process");
+                    }
+                    this.logger.info({ name, fields: [...HOT_INSTANCE_CONFIG_KEYS] }, "Instance hot config reloaded");
+                }
             }
         }
+        // warm_cap is fleet-owned; enforce the reloaded value immediately against
+        // currently idle instances instead of waiting for a future state edge.
+        this.enforceWarmCap();
         this.logger.info({ running: this.daemons.size, configured: Object.keys(newInstances).length }, "Reconcile complete");
     }
     async restartInstances() {
@@ -7098,7 +8433,7 @@ When users create specialized instances, suggest these configurations:
                 if (generalId) {
                     // No release URL — Discord's SuppressEmbeds proved unreliable and the
                     // link preview looked bad. Version + /update instruction is enough.
-                    this.notifyInstanceTopic(generalId, t("update.available", `v${target}`) + ` (current: v${currentVersion})`);
+                    this.notifyInstanceTopic(generalId, t("update.available_current", `v${target}`, `v${currentVersion}`));
                 }
             }
         }
@@ -7418,7 +8753,7 @@ When users create specialized instances, suggest these configurations:
             if (err.code === "EADDRINUSE") {
                 if (this.healthPortRetried) {
                     this.logger.error({ err, port }, "Health port still in use after takeover — dashboard disabled");
-                    this.notifyFleetError(`⚠️ Dashboard unavailable — health port ${port} is already in use. Stop the conflicting process or configure a different health_port.`);
+                    this.notifyFleetError(t("dashboard.port_in_use", port));
                     return;
                 }
                 this.healthPortRetried = true;
@@ -7444,7 +8779,7 @@ When users create specialized instances, suggest these configurations:
                 return;
             }
             this.logger.error({ err, port }, "Health server error");
-            this.notifyFleetError(`⚠️ Dashboard unavailable — health server failed: ${err.message}`);
+            this.notifyFleetError(t("dashboard.server_failed", err.message));
         });
         this.healthServer.listen(port, "127.0.0.1", () => markListening());
     }