@songsid/agend 2.1.4-beta.17 → 2.1.4-beta.19

package/dist/fleet-manager.js

@@ -31,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, CLEAR_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";
@@ -45,7 +45,7 @@ import { handleWebRequest, broadcastSseEvent } from "./web-api.js";
 import { handleViewRequest, isViewPath } from "./view-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";
@@ -56,6 +56,7 @@ 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) {
@@ -206,9 +207,12 @@ const INTERACTIVE_ASSIST_CALLBACK_PREFIX = "interactive-assist:";
 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;
@@ -255,6 +259,7 @@ export class FleetManager {
     costGuard = null;
     statuslineWatcher;
     dailySummary = null;
+    dailyTipScheduler = null;
     webhookEmitter = null;
     // Topic icon + auto-archive state
     topicIcons = {};
@@ -267,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. */
@@ -325,6 +337,7 @@ export class FleetManager {
     updateProgressTimer = null;
     updateProgressEditRunning = false;
     lastUpdateProgressText = null;
+    updateCompletionTipText = null;
     eventLogPruneTimer = null;
     logRotateTimer = null;
     /** Days of event/activity history to keep. */
@@ -373,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;
@@ -623,6 +636,36 @@ export class FleetManager {
         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 === "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)) {
@@ -911,7 +954,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"
@@ -933,8 +976,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) {
@@ -992,22 +1039,32 @@ export class FleetManager {
                 finish(false);
         });
     }
-    async deliverWithIdleGate(instanceName, payload, timeoutMs) {
+    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());
     }
     /**
@@ -1026,7 +1083,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);
@@ -1035,7 +1094,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(() => { });
@@ -1052,10 +1115,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);
@@ -1073,6 +1138,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;
@@ -1084,16 +1151,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;
@@ -1178,7 +1249,7 @@ export class FleetManager {
             // routing instructions are not injected, so it cannot act as a dispatcher.
             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);
         }
@@ -1483,6 +1554,7 @@ export class FleetManager {
             messageId,
         });
         this.lastUpdateProgressText = null;
+        this.updateCompletionTipText = null;
         this.startUpdateProgressMonitor(adapter);
     }
     failUpdateProgress(message) {
@@ -1506,7 +1578,17 @@ export class FleetManager {
             const adapter = this.adapters.get(target.adapterId) ?? (initialAdapter?.id === target.adapterId ? initialAdapter : undefined);
             if (!adapter)
                 return;
-            const text = formatUpdateProgress(marker);
+            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;
@@ -1794,6 +1876,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.
@@ -1976,6 +2065,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;
@@ -2137,14 +2232,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. */
@@ -2242,6 +2337,10 @@ export class FleetManager {
             await this.handleInboundReaction(r);
         }, this.logger, "adapter.reaction"));
         this.adapter.on("callback_query", safeHandler(async (data) => {
+            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))
@@ -2354,6 +2453,23 @@ export class FleetManager {
                 });
                 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);
             }
@@ -2430,9 +2546,12 @@ export class FleetManager {
                     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.
@@ -2498,6 +2617,23 @@ export class FleetManager {
                 });
                 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.
@@ -2574,6 +2710,10 @@ export class FleetManager {
             await this.handleInboundReaction(r);
         }, this.logger, `adapter[${adapterId}].reaction`));
         adapter.on("callback_query", safeHandler(async (data) => {
+            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))
@@ -2732,9 +2872,12 @@ export class FleetManager {
                     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.
@@ -2800,6 +2943,23 @@ export class FleetManager {
                 });
                 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) {
@@ -3385,6 +3545,24 @@ export class FleetManager {
                     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@")) {
@@ -3412,7 +3590,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
@@ -3449,7 +3627,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);
@@ -3667,10 +3845,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;
@@ -3831,7 +4009,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");
             }
@@ -3846,10 +4028,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);
@@ -4560,7 +4751,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
@@ -4571,7 +4762,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) {
@@ -4625,9 +4816,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. */
@@ -4729,7 +4920,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
@@ -4783,7 +4974,8 @@ export class FleetManager {
     //
     // 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,
+    // 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.
     /**
@@ -4865,11 +5057,14 @@ export class FleetManager {
             return "consumed";
         }
         // Bind the capability to the exact message/world that created it. Telegram
-        // keyboards are visible to everyone, so the click also requires fleet admin.
+        // 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.authChannelId
-                ? this.isModelAdmin(data.userId, pending.authChannelId, callbackAdapterId)
-                : this.isFleetAdmin(data.userId, callbackAdapterId)
+            ? 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
@@ -4902,10 +5097,156 @@ export class FleetManager {
             this.logger.warn({ err, instanceName: pending.instanceName }, "Failed to retire prompt buttons");
         }
     }
+    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)}`;
+    }
+    /** 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;
+        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;
+        }
+        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, t("tips.dismissed"));
+        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 CLEAR_UNSUPPORTED_MSG;
+            return t("clear.unsupported");
         const adapterId = adapter.id;
         if (!adapterId)
             return t("clear.prompt_unavailable");
@@ -5179,7 +5520,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") {
@@ -5731,11 +6072,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)
@@ -6724,10 +7081,10 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
     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) {
@@ -6748,11 +7105,11 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
         }
         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;
@@ -6765,20 +7122,20 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
         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");
@@ -6794,13 +7151,13 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
             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;
@@ -6810,7 +7167,7 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
             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. */
@@ -6831,7 +7188,7 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
         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;
@@ -6863,7 +7220,7 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
             }
             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) {
@@ -6900,12 +7257,12 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
         }
         // 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.
@@ -6919,13 +7276,13 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
         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"));
         }
     }
     /**
@@ -6936,7 +7293,7 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
     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");
@@ -6952,13 +7309,13 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
             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;
@@ -6968,7 +7325,7 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
             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). */
@@ -6991,7 +7348,7 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
         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
@@ -7028,7 +7385,7 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
             }
             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) {
@@ -7125,17 +7482,17 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
         }
         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]) {
@@ -7144,12 +7501,12 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
         }
         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);
@@ -7158,9 +7515,9 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
             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`;
+        const warn = isModelCompatible(backendName, model) ? "" : t("model.pattern_warning", model, backendName);
         if (strategy === "runtime" && !this.instanceIpcClients.get(instanceName)) {
-            return `${warn}❌ ${instanceName} is not running.`;
+            return `${warn}${t("effort.not_running", instanceName)}`;
         }
         // 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.
@@ -7174,13 +7531,13 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
             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}✅ Switched ${instanceName} to \`${model}\` (runtime).${this.effortSuffix(instanceName)}`;
+            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.
@@ -7194,10 +7551,10 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
             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) {
@@ -7232,7 +7589,7 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
     /** 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)
@@ -7402,7 +7759,7 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
             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;
@@ -7424,7 +7781,7 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
     /** 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");
@@ -7471,6 +7828,8 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
         this.clearStatuslineWatchers();
         this.costGuard?.stop();
         this.dailySummary?.stop();
+        this.dailyTipScheduler?.stop();
+        this.dailyTipScheduler = null;
         if (this.updateCheckTimer) {
             clearTimeout(this.updateCheckTimer);
             clearInterval(this.updateCheckTimer);
@@ -7731,11 +8090,11 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
             // 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);
@@ -7745,12 +8104,16 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
         const topicMode = this.fleetConfig?.channel?.mode === "topic";
         // Detect fleet-level changes which still need a restart. Hot defaults are
         // reconciled below and must not produce a misleading restart warning.
-        const oldDefaultCold = oldConfig?.defaults
+        const oldDefaultColdWithFleetFields = oldConfig?.defaults
             ? splitHotColdConfig(oldConfig.defaults).cold
             : {};
-        const newDefaultCold = this.fleetConfig?.defaults
+        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) {
@@ -8040,7 +8403,7 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
                 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}`));
                 }
             }
         }
@@ -8360,7 +8723,7 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
             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;
@@ -8386,7 +8749,7 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
                 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());
     }