@songsid/agend 2.0.11-beta.8 → 2.0.11

package/dist/fleet-manager.js

@@ -8,6 +8,8 @@ import { sdNotify } from "./sd-notify.js";
 import yaml from "js-yaml";
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
+/** Fallback access policy for a channel with no `access:` block — open (no gate). */
+const DEFAULT_OPEN_ACCESS = { mode: "open", allowed_users: [], max_pending_codes: 0, code_expiry_minutes: 0 };
 import { isProbeableRouteTarget } from "./fleet-context.js";
 import { loadFleetConfig, DEFAULT_COST_GUARD, DEFAULT_DAILY_SUMMARY, DEFAULT_INSTANCE_CONFIG } from "./config.js";
 import { EventLog } from "./event-log.js";
@@ -22,7 +24,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, sanitizeInstanceName, saveCommandForBackend, parseSaveFilename, SAVE_FILENAME_RE, SAVE_UNSUPPORTED_MSG } from "./topic-commands.js";
+import { TopicCommands, saveCommandForBackend, parseSaveFilename, SAVE_FILENAME_RE, SAVE_UNSUPPORTED_MSG } from "./topic-commands.js";
 import { DailySummary } from "./daily-summary.js";
 import { WebhookEmitter } from "./webhook-emitter.js";
 import { TmuxControlClient } from "./tmux-control.js";
@@ -34,8 +36,10 @@ 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 { handleSettingsRequest } from "./settings-api.js";
+import { setLocale, detectLocale, t } from "./locale.js";
 import { handleAgentRequest } from "./agent-endpoint.js";
-import { ClassicChannelManager, classicInstanceName } from "./classic-channel-manager.js";
+import { ClassicChannelManager } from "./classic-channel-manager.js";
 import { getTmuxSession } from "./config.js";
 export function resolveReplyThreadId(argsThreadId, instanceConfig) {
     if (typeof argsThreadId === "string" && argsThreadId.length > 0) {
@@ -179,27 +183,51 @@ export class FleetManager {
         }
         return this.routing.map;
     }
-    /** Re-register classic channels after routing rebuild (rebuild clears the table) */
+    /**
+     * Refresh each adapter's open-channel whitelist after a classic change.
+     * Classic channels are NOT registered in the routing engine (it's single-key
+     * per channel — can't represent two bots in one channel); routing resolves
+     * per-bot via ClassicChannelManager.getInstanceByChannel. Each adapter only
+     * opens the channels IT owns so a sibling bot doesn't process another's cross-
+     * guild channel.
+     */
     reregisterClassicChannels() {
         if (!this.classicChannels)
             return;
         const channels = this.classicChannels.getAll();
-        for (const ch of channels) {
-            this.routing.register(ch.channelId, { kind: "classic", name: ch.instanceName });
-        }
         // Always update adapter openChannels (including empty — clears stale entries on /stop)
-        for (const [, w] of this.worlds) {
+        for (const [adapterId, w] of this.worlds) {
             if (typeof w.adapter?.setOpenChannels === "function") {
-                w.adapter.setOpenChannels(channels.map(ch => ch.channelId));
+                const owned = channels.filter(ch => ch.adapterId === adapterId).map(ch => ch.channelId);
+                w.adapter.setOpenChannels(owned);
             }
         }
         if (channels.length > 0) {
-            this.logger.info({ count: channels.length }, "Registered classic channel routes");
+            this.logger.info({ count: channels.length }, "Refreshed classic channel open-lists");
         }
     }
     getInstanceDir(name) {
         return join(this.dataDir, "instances", name);
     }
+    /** AgEnD package version (for the Settings "current version" / What's New). */
+    get currentVersion() {
+        try {
+            return JSON.parse(readFileSync(join(__dirname, "..", "package.json"), "utf-8")).version ?? "unknown";
+        }
+        catch {
+            return "unknown";
+        }
+    }
+    /**
+     * Resolve a slash-command target in a channel. Classic channels are looked up
+     * per-bot (same-channel multi-bot); a fleet-topic instance is found via the
+     * routing engine. Used by commands that work in BOTH contexts (/ctx, /compact,
+     * /cancel). Classic-only commands (/chat, /load) must NOT use this.
+     */
+    resolveSlashTarget(channelId, adapterId) {
+        return this.classicChannels?.getInstanceByChannel(channelId, adapterId)
+            ?? this.routing.resolve(channelId)?.name;
+    }
     /** Get the adapter bound to an instance, falling back to primary adapter */
     getAdapterForInstance(name) {
         const worldId = this.instanceWorldBinding.get(name);
@@ -237,6 +265,12 @@ export class FleetManager {
         const cfg = this.fleetConfig?.instances[name];
         if (fromInbound && (cfg?.general_topic || cfg?.channel_id))
             return;
+        // A classic instance is bound authoritatively at /start. Don't let an inbound
+        // (seen by every same-guild bot) override an existing binding — but if there
+        // is none yet (e.g. after a restart, before v2.1 persistence), allow inbound
+        // to re-establish it so replies don't fall back to the primary bot forever.
+        if (fromInbound && this.classicChannels?.getChannelIdByInstance(name) !== undefined && this.instanceWorldBinding.has(name))
+            return;
         this.instanceWorldBinding.set(name, adapterId);
     }
     getInstanceStatus(name) {
@@ -364,6 +398,7 @@ export class FleetManager {
         const { rotateLogIfNeeded } = await import("./logger.js");
         rotateLogIfNeeded(join(this.dataDir, "fleet.log"));
         const fleet = this.loadConfig(configPath);
+        setLocale(detectLocale(fleet)); // user-facing text language (fleet.yaml defaults.locale / timezone)
         const topicMode = fleet.channel?.mode === "topic" || !!fleet.channels?.some(ch => ch.mode === "topic");
         // Set tmux socket isolation for custom AGEND_HOME
         const { getTmuxSocketName: getSocket } = await import("./paths.js");
@@ -405,10 +440,19 @@ export class FleetManager {
         const pidPath = join(this.dataDir, "fleet.pid");
         writeFileSync(pidPath, String(process.pid), "utf-8");
         this.eventLog = new EventLog(join(this.dataDir, "events.db"));
-        // Initialize classic channel manager and register existing channels in routing
+        // Initialize classic channel manager. The primary adapter (channels[0])
+        // migrates legacy single-bot entries and names without a suffix. Classic
+        // 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);
+        // 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()) {
-            this.routing.register(ch.channelId, { kind: "classic", name: ch.instanceName });
+            if (ch.adapterId)
+                this.instanceWorldBinding.set(ch.instanceName, ch.adapterId);
         }
         // Poll classicBot.yaml for external changes every 30s
         this.classicReloadTimer = setInterval(async () => {
@@ -416,21 +460,27 @@ export class FleetManager {
                 if (!this.classicChannels)
                     return;
                 const fleetBackend = this.fleetConfig?.defaults?.backend;
+                const fleetModel = this.fleetConfig?.defaults?.model;
                 const oldBackends = new Map();
+                const oldModels = new Map();
                 for (const ch of this.classicChannels.getAll()) {
                     oldBackends.set(ch.instanceName, this.classicChannels.getBackendByInstance(ch.instanceName, fleetBackend));
+                    oldModels.set(ch.instanceName, this.classicChannels.getModel(ch.channelId, ch.adapterId, fleetModel));
                 }
                 if (!this.classicChannels.checkReload())
                     return;
                 this.reregisterClassicChannels();
                 for (const ch of this.classicChannels.getAll()) {
                     const newBackend = this.classicChannels.getBackendByInstance(ch.instanceName, fleetBackend);
-                    if (this.daemons.has(ch.instanceName) && oldBackends.get(ch.instanceName) !== newBackend) {
-                        this.logger.info({ instanceName: ch.instanceName, from: oldBackends.get(ch.instanceName), to: newBackend }, "Backend changed — restarting");
+                    const newModel = this.classicChannels.getModel(ch.channelId, ch.adapterId, fleetModel);
+                    const backendChanged = oldBackends.get(ch.instanceName) !== newBackend;
+                    const modelChanged = oldModels.get(ch.instanceName) !== newModel;
+                    if (this.daemons.has(ch.instanceName) && (backendChanged || modelChanged)) {
+                        this.logger.info({ instanceName: ch.instanceName, backendFrom: oldBackends.get(ch.instanceName), backendTo: newBackend, modelFrom: oldModels.get(ch.instanceName), modelTo: newModel }, "Backend/model changed — restarting");
                         await this.stopInstance(ch.instanceName).catch(() => { });
                         // Small delay to let tmux window clean up
                         await new Promise(r => setTimeout(r, 2000));
-                        await this.startClassicInstance(ch.instanceName, newBackend).catch(err => this.logger.warn({ err, instanceName: ch.instanceName }, "Failed to restart classic instance"));
+                        await this.startClassicInstance(ch.instanceName, newBackend, this.classicChannels.getPreTaskCommand(ch.channelId, ch.adapterId), newModel).catch(err => this.logger.warn({ err, instanceName: ch.instanceName }, "Failed to restart classic instance"));
                     }
                 }
             }
@@ -450,11 +500,11 @@ export class FleetManager {
             this.logger.info({ count: webhookConfigs.length }, "Webhook emitter initialized");
         }
         this.costGuard.on("warn", safeHandler((instance, totalCents, limitCents) => {
-            this.notifyInstanceTopic(instance, `⚠️ ${instance} cost: ${formatCents(totalCents)} / ${formatCents(limitCents)} (${Math.round(totalCents / limitCents * 100)}%)`);
+            this.notifyInstanceTopic(instance, t("cost.approaching", instance, formatCents(totalCents), formatCents(limitCents), Math.round(totalCents / limitCents * 100)));
             this.webhookEmitter?.emit("cost_warning", instance, { cost_cents: totalCents, limit_cents: limitCents });
         }, this.logger, "costGuard.warn"));
         this.costGuard.on("limit", safeHandler(async (instance, totalCents, limitCents) => {
-            this.notifyInstanceTopic(instance, `🛑 ${instance} daily limit ${formatCents(limitCents)} reached — pausing instance.`);
+            this.notifyInstanceTopic(instance, t("cost.limit_reached", instance, formatCents(limitCents)));
             this.eventLog?.insert(instance, "instance_paused", { reason: "cost_limit", cost_cents: totalCents });
             this.webhookEmitter?.emit("cost_limit", instance, { cost_cents: totalCents, limit_cents: limitCents });
             await this.stopInstance(instance);
@@ -486,8 +536,9 @@ export class FleetManager {
         // Rotate classic channel chat logs daily (piggyback on daily summary timer)
         this.classicChannels?.rotateLogs();
         this.rotateInboxes();
-        // Auto-create general instance(s) — one per adapter that lacks a general
+        // Auto-create/adopt a general dispatcher — ONLY for the primary adapter.
         const channelConfigs = fleet.channels ?? (fleet.channel ? [fleet.channel] : []);
+        const primaryAdapterId = channelConfigs[0] ? (channelConfigs[0].id ?? channelConfigs[0].type) : undefined;
         const generalInstances = Object.entries(fleet.instances).filter(([, inst]) => inst.general_topic === true);
         let generalsCreated = false;
         // Collect unbound generals (no channel_id set) for auto-assignment
@@ -496,6 +547,14 @@ export class FleetManager {
         const needsGeneral = [];
         for (const ch of channelConfigs) {
             const adapterId = ch.id ?? ch.type;
+            // Only the primary adapter gets an auto-general. Secondary (persona) bots
+            // answer for their explicitly-bound instances only — they don't need or
+            // auto-claim a general dispatcher, and must never adopt the primary's
+            // unbound general. A general a user manually bound to a secondary
+            // (channel_id: <persona>) is left untouched — the auto logic just won't
+            // create or reassign bindings for non-primary adapters.
+            if (adapterId !== primaryAdapterId)
+                continue;
             // Check if any general is explicitly bound to this adapter
             if (generalInstances.some(([, inst]) => inst.channel_id === adapterId))
                 continue;
@@ -598,7 +657,7 @@ export class FleetManager {
                     if (this.adapter && topicId) {
                         const chatId = this.adapter.getChatId?.() ?? "";
                         if (chatId) {
-                            this.adapter.sendText(chatId, `⚠️ General instance "${name}" failed to start:\n${errorMsg}`, { threadId: topicId }).catch(() => { });
+                            this.adapter.sendText(chatId, t("general.start_failed", name, errorMsg), { threadId: topicId }).catch(() => { });
                         }
                     }
                 }
@@ -638,6 +697,23 @@ export class FleetManager {
                     }
                 }
             }
+            // Guard against a stale/invalid general topic_id. An old auto-general
+            // could have written the TG-convention "1" for a Discord general; the DC
+            // adapter then throws fetching channel "1" → unhandled → fleet crash loop.
+            // Unbind (+ warn) so it's simply skipped, never routed to a bogus channel.
+            let fixedGeneral = false;
+            for (const [name, cfg] of Object.entries(this.fleetConfig.instances)) {
+                if (!cfg.general_topic || cfg.topic_id == null)
+                    continue;
+                const adapterId = this.instanceWorldBinding.get(name) ?? cfg.channel_id;
+                if (this.getChannelConfig(adapterId)?.type === "discord" && !/^\d{17,}$/.test(String(cfg.topic_id))) {
+                    this.logger.warn({ name, topic_id: cfg.topic_id }, "Discord general topic_id is not a valid channel — unbinding to avoid a crash loop");
+                    delete cfg.topic_id;
+                    fixedGeneral = true;
+                }
+            }
+            if (fixedGeneral)
+                this.saveFleetConfig();
             // Auto-create topics AFTER adapter is ready (needs adapter.createTopic)
             await this.topicCommands.autoCreateTopics();
             const routeSummary = this.routing.rebuild(this.fleetConfig);
@@ -657,7 +733,7 @@ export class FleetManager {
                 let idx = 0;
                 while (idx < channels.length) {
                     const batch = channels.slice(idx, idx + concurrency);
-                    await Promise.allSettled(batch.map(ch => this.startClassicInstance(ch.instanceName, this.classicChannels.getBackendByInstance(ch.instanceName, fleetBackend)).catch(err => this.logger.warn({ err, instanceName: ch.instanceName }, "Failed to start classic instance"))));
+                    await Promise.allSettled(batch.map(ch => this.startClassicInstance(ch.instanceName, this.classicChannels.getBackendByInstance(ch.instanceName, fleetBackend), this.classicChannels.getPreTaskCommand(ch.channelId, ch.adapterId), this.classicChannels.getModel(ch.channelId, ch.adapterId, this.fleetConfig?.defaults?.model)).catch(err => this.logger.warn({ err, instanceName: ch.instanceName }, "Failed to start classic instance"))));
                     idx += concurrency;
                 }
             }
@@ -676,8 +752,8 @@ export class FleetManager {
             const agendVersion = _require("../package.json").version ?? "unknown";
             if (this.adapter && fleet.channel?.group_id) {
                 const text = failedNames.length === 0
-                    ? `Fleet ready. ${started}/${total} instances running. v${agendVersion}`
-                    : `Fleet ready. ${started}/${total} instances running. v${agendVersion} | Failed: ${failedNames.join(", ")}`;
+                    ? t("fleet.ready", started, total, agendVersion)
+                    : t("fleet.ready_with_failed", started, total, agendVersion, failedNames.join(", "));
                 this.adapter.sendText(String(fleet.channel.group_id), text, {
                     threadId: generalThreadId != null ? String(generalThreadId) : undefined,
                 }).catch(e => this.logger.warn({ err: e }, "Failed to send fleet start notification"));
@@ -761,15 +837,14 @@ export class FleetManager {
         if (channelConfigs.length === 0)
             return;
         // Start primary adapter (first channel) — this.adapter for backward compat.
-        // The primary owns the guild's slash commands.
         await this.startSingleAdapter(fleet, channelConfigs[0]);
-        const primaryGroup = String(channelConfigs[0].group_id ?? "");
-        // Start additional adapters. A secondary bot in the SAME guild as the primary
-        // must not re-register the guild's slash commands (they'd appear twice); a bot
-        // in a different guild still registers its own.
+        // Start additional adapters. Every bot registers its own slash commands —
+        // Discord slash commands are per-application, so a same-guild secondary bot's
+        // /start etc. are distinct entries (labelled with the bot name) and the
+        // interaction only reaches the invoked bot. This is how ClassicBot supports
+        // multiple bots in one guild: the user picks which bot from autocomplete.
         for (let i = 1; i < channelConfigs.length; i++) {
-            const sameGuild = String(channelConfigs[i].group_id ?? "") === primaryGroup;
-            await this.startAdditionalAdapter(channelConfigs[i], !sameGuild);
+            await this.startAdditionalAdapter(channelConfigs[i]);
         }
     }
     /** Start the primary adapter (backward-compatible, sets this.adapter) */
@@ -781,7 +856,7 @@ export class FleetManager {
         }
         const accessDir = join(this.dataDir, "access");
         mkdirSync(accessDir, { recursive: true });
-        const accessManager = new AccessManager(channelConfig.access, join(accessDir, "access.json"));
+        const accessManager = new AccessManager(channelConfig.access ?? DEFAULT_OPEN_ACCESS, join(accessDir, "access.json"));
         this.accessManager = accessManager;
         const inboxDir = join(this.dataDir, "inbox");
         mkdirSync(inboxDir, { recursive: true });
@@ -837,28 +912,28 @@ export class FleetManager {
         // Handle classic bot slash commands (/start, /stop, /chat, /compact, /save, /load)
         this.adapter.on("slash_command", safeHandler(async (data) => {
             if (data.command === "start") {
-                const reply = await this.handleClassicStart(data.channelId, data.channelName, data.userId, data.guildId);
+                const reply = await this.handleClassicStart(data.channelId, data.channelName, data.userId, data.guildId, adapterId);
                 await data.respond(reply);
             }
             else if (data.command === "stop") {
-                const reply = await this.handleClassicStop(data.channelId);
+                const reply = await this.handleClassicStop(data.channelId, adapterId);
                 await data.respond(reply);
             }
             else if (data.command === "chat") {
                 const text = data.text ?? "";
                 if (!text) {
-                    await data.respond("Usage: `/chat <message>`");
+                    await data.respond(t("chat.usage"));
                     return;
                 }
-                const target = this.routing.resolve(data.channelId);
-                if (!target || target.kind !== "classic") {
-                    await data.respond("No active agent in this channel. Use `/start` first.");
+                const name = this.classicChannels?.getInstanceByChannel(data.channelId, adapterId);
+                if (!name) {
+                    await data.respond(t("classic.no_agent_start"));
                     return;
                 }
                 const replyMsgId = await data.respond("👀");
                 const username = data.username ?? data.userId;
-                ClassicChannelManager.logMessage(target.name, username, `/chat ${text}`, new Date());
-                await this.forwardToClassicInstance(target.name, text, {
+                ClassicChannelManager.logMessage(name, username, `/chat ${text}`, new Date());
+                await this.forwardToClassicInstance(name, text, {
                     chatId: data.channelId,
                     threadId: data.channelId,
                     messageId: replyMsgId ?? "",
@@ -869,86 +944,88 @@ export class FleetManager {
                 });
             }
             else if (data.command === "save") {
-                await this.handleSlashSave(data);
+                await this.handleSlashSave(data, adapterId);
             }
             else if (data.command === "load") {
                 // load is kiro-cli/classic only — no claude-code equivalent.
                 if (!this.classicChannels?.isAdmin(data.userId)) {
-                    await data.respond("⛔ This command requires admin access.");
+                    await data.respond(t("admin.required"));
                     return;
                 }
-                const target = this.routing.resolve(data.channelId);
-                if (!target || target.kind !== "classic") {
-                    await data.respond("No active agent in this channel. Use `/start` first.");
+                const name = this.classicChannels?.getInstanceByChannel(data.channelId, adapterId);
+                if (!name) {
+                    await data.respond(t("classic.no_agent_start"));
                     return;
                 }
                 const filename = data.options?.filename;
                 if (!SAVE_FILENAME_RE.test(filename ?? "")) {
-                    await data.respond("⛔ Invalid filename — only letters, numbers, dots, hyphens, underscores allowed.");
+                    await data.respond(t("filename.invalid"));
                     return;
                 }
-                this.pasteRawToClassicInstance(target.name, `/chat load ${filename}`);
-                await data.respond(`✅ Sent \`/chat load ${filename}\` to ${target.name}`);
+                this.pasteRawToClassicInstance(name, `/chat load ${filename}`);
+                await data.respond(t("save.sent", `/chat load ${filename}`, name));
             }
             else if (data.command === "compact") {
-                const target = this.routing.resolve(data.channelId);
-                if (!target) {
-                    await data.respond("No active agent in this channel.");
+                const name = this.resolveSlashTarget(data.channelId, adapterId);
+                if (!name) {
+                    await data.respond(t("classic.no_agent"));
                     return;
                 }
-                const result = await this.topicCommands.sendCompact(target.name);
+                const result = await this.topicCommands.sendCompact(name);
                 await data.respond(result);
             }
             else if (data.command === "cancel") {
-                const target = this.routing.resolve(data.channelId);
-                if (!target) {
-                    await data.respond("No active agent in this channel.");
+                const name = this.resolveSlashTarget(data.channelId, adapterId);
+                if (!name) {
+                    await data.respond(t("classic.no_agent"));
                     return;
                 }
-                const ok = this.cancelInstance(target.name);
-                await data.respond(ok ? `🛑 Sent cancel to ${target.name}.` : `❌ ${target.name} not running.`);
+                const ok = this.cancelInstance(name);
+                await data.respond(ok ? t("cancel.sent", name) : t("cancel.not_running", name));
             }
             else if (data.command === "ctx") {
-                const target = this.routing.resolve(data.channelId);
-                if (!target) {
-                    await data.respond("No active agent in this channel.");
+                const name = this.resolveSlashTarget(data.channelId, adapterId);
+                if (!name) {
+                    await data.respond(t("classic.no_agent"));
                     return;
                 }
                 // Single source of truth (statusline.json + robust tmux pane fallback).
-                await data.respond(await this.topicCommands.getCtxText(target.name));
+                await data.respond(await this.topicCommands.getCtxText(name));
             }
             else if (data.command === "collab") {
+                // Classic no longer lives in the routing engine, so a routing hit here is
+                // always a fleet-topic instance.
                 const collabTarget = this.routing.resolve(data.channelId);
-                if (collabTarget && collabTarget.kind !== "classic") {
+                if (collabTarget) {
                     const allowed = this.fleetConfig?.channel?.access?.allowed_users ?? [];
                     if (allowed.length > 0 && !allowed.some(u => String(u) === String(data.userId))) {
-                        await data.respond("⛔ Not authorized");
+                        await data.respond(t("not_authorized"));
                         return;
                     }
                     const isCollab = this.toggleFleetCollab(collabTarget.name);
-                    await data.respond(isCollab ? "🤝 Collaboration mode **ON** — bot/webhook messages reach the agent." : "💬 Collaboration mode **OFF**");
+                    await data.respond(isCollab ? t("collab.on") : t("collab.off"));
                     return;
                 }
                 if (!this.classicChannels?.isAdmin(data.userId)) {
-                    await data.respond("⛔ This command requires admin access.");
+                    await data.respond(t("admin.required"));
                     return;
                 }
-                if (!this.classicChannels.isClassicChannel(data.channelId)) {
-                    await data.respond("No active agent in this channel. Use `/start` first.");
+                if (!this.classicChannels.isClassicChannel(data.channelId, adapterId)) {
+                    await data.respond(t("classic.no_agent_start"));
                     return;
                 }
-                const newState = this.classicChannels.toggleCollab(data.channelId);
+                const newState = this.classicChannels.toggleCollab(data.channelId, adapterId);
                 await data.respond(newState
-                    ? "🤝 Collaboration mode **ON** — @mention this bot to trigger the agent. Other bot messages are visible."
-                    : "💬 Collaboration mode **OFF** — use `/chat` to talk to the agent.");
+                    ? t("collab.on.classic")
+                    : 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("⛔ Not authorized");
+                    await data.respond(t("not_authorized"));
                     return;
                 }
-                await data.respond("📦 Updating AgEnD... Fleet will restart automatically.");
+                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";
@@ -958,7 +1035,7 @@ export class FleetManager {
             else if (data.command === "doctor") {
                 const allowed = this.fleetConfig?.channel?.access?.allowed_users ?? [];
                 if (allowed.length > 0 && !allowed.some(u => String(u) === String(data.userId))) {
-                    await data.respond("⛔ Not authorized");
+                    await data.respond(t("not_authorized"));
                     return;
                 }
                 try {
@@ -980,22 +1057,36 @@ export class FleetManager {
             else if (data.command === "sysinfo") {
                 await data.respond(this.topicCommands.getSysInfoText());
             }
+            else if (data.command === "dashboard") {
+                // Reply is ephemeral (adapter defers non-chat commands ephemerally), so
+                // the web-token-bearing URLs are only visible to the caller.
+                const allowed = this.fleetConfig?.channel?.access?.allowed_users ?? [];
+                if (allowed.length === 0) {
+                    await data.respond(t("dashboard.disabled"));
+                    return;
+                }
+                if (!allowed.some(u => String(u) === String(data.userId))) {
+                    await data.respond(t("not_authorized"));
+                    return;
+                }
+                await data.respond(this.topicCommands.getDashboardText());
+            }
             else if (data.command === "restart") {
                 const allowed = this.fleetConfig?.channel?.access?.allowed_users ?? [];
                 if (allowed.length > 0 && !allowed.some(u => String(u) === String(data.userId))) {
-                    await data.respond("⛔ Not authorized");
+                    await data.respond(t("not_authorized"));
                     return;
                 }
-                await data.respond("🔄 Graceful restart — waiting for instances to idle...");
+                await data.respond(t("restart.graceful"));
                 process.kill(process.pid, "SIGUSR2");
             }
             else if (data.command === "compact") {
-                const target = this.routing.resolve(data.channelId);
-                if (!target) {
-                    await data.respond("No active agent in this channel.");
+                const name = this.resolveSlashTarget(data.channelId, adapterId);
+                if (!name) {
+                    await data.respond(t("classic.no_agent"));
                     return;
                 }
-                const result = await this.topicCommands.sendCompact(target.name);
+                const result = await this.topicCommands.sendCompact(name);
                 await data.respond(result);
             }
         }, this.logger, "adapter.slash_command"));
@@ -1022,7 +1113,7 @@ export class FleetManager {
             this.restartAdapter(this.adapter, "primary").catch(() => { });
         });
         this.adapter.on("new_group_detected", safeHandler((data) => {
-            const adminMsg = `🆕 Bot added to new server:\n• Name: ${data.groupTitle}\n• ID: ${data.groupId}\n• Platform: ${data.source}\n\nTo allow: add \`${data.groupId}\` to classicBot.yaml \`allowed_guilds\``;
+            const adminMsg = t("alert.bot_added", data.groupTitle, data.groupId, data.source);
             const generalId = this.findGeneralInstance();
             if (generalId)
                 this.notifyInstanceTopic(generalId, adminMsg);
@@ -1048,7 +1139,7 @@ export class FleetManager {
         }
         const accessDir = join(this.dataDir, "access");
         mkdirSync(accessDir, { recursive: true });
-        const accessManager = new AccessManager(channelConfig.access, join(accessDir, `access-${adapterId}.json`));
+        const accessManager = new AccessManager(channelConfig.access ?? DEFAULT_OPEN_ACCESS, join(accessDir, `access-${adapterId}.json`));
         const inboxDir = join(this.dataDir, "inbox");
         mkdirSync(inboxDir, { recursive: true });
         const adapter = await createAdapter(channelConfig, {
@@ -1100,28 +1191,28 @@ export class FleetManager {
         // Slash commands: classic bot + admin commands
         adapter.on("slash_command", safeHandler(async (data) => {
             if (data.command === "start") {
-                const reply = await this.handleClassicStart(data.channelId, data.channelName, data.userId, data.guildId);
+                const reply = await this.handleClassicStart(data.channelId, data.channelName, data.userId, data.guildId, adapterId);
                 await data.respond(reply);
             }
             else if (data.command === "stop") {
-                const reply = await this.handleClassicStop(data.channelId);
+                const reply = await this.handleClassicStop(data.channelId, adapterId);
                 await data.respond(reply);
             }
             else if (data.command === "chat") {
                 const text = data.text ?? "";
                 if (!text) {
-                    await data.respond("Usage: `/chat <message>`");
+                    await data.respond(t("chat.usage"));
                     return;
                 }
-                const target = this.routing.resolve(data.channelId);
-                if (!target || target.kind !== "classic") {
-                    await data.respond("No active agent in this channel. Use `/start` first.");
+                const name = this.classicChannels?.getInstanceByChannel(data.channelId, adapterId);
+                if (!name) {
+                    await data.respond(t("classic.no_agent_start"));
                     return;
                 }
                 const replyMsgId = await data.respond("👀");
                 const username = data.username ?? data.userId;
-                ClassicChannelManager.logMessage(target.name, username, `/chat ${text}`, new Date());
-                await this.forwardToClassicInstance(target.name, text, {
+                ClassicChannelManager.logMessage(name, username, `/chat ${text}`, new Date());
+                await this.forwardToClassicInstance(name, text, {
                     chatId: data.channelId,
                     threadId: data.channelId,
                     messageId: replyMsgId ?? "",
@@ -1132,86 +1223,79 @@ export class FleetManager {
                 });
             }
             else if (data.command === "save") {
-                await this.handleSlashSave(data);
+                await this.handleSlashSave(data, adapterId);
             }
             else if (data.command === "load") {
                 // load is kiro-cli/classic only — no claude-code equivalent.
                 if (!this.classicChannels?.isAdmin(data.userId)) {
-                    await data.respond("⛔ This command requires admin access.");
+                    await data.respond(t("admin.required"));
                     return;
                 }
-                const target = this.routing.resolve(data.channelId);
-                if (!target || target.kind !== "classic") {
-                    await data.respond("No active agent in this channel. Use `/start` first.");
+                const name = this.classicChannels?.getInstanceByChannel(data.channelId, adapterId);
+                if (!name) {
+                    await data.respond(t("classic.no_agent_start"));
                     return;
                 }
                 const filename = data.options?.filename;
                 if (!SAVE_FILENAME_RE.test(filename ?? "")) {
-                    await data.respond("⛔ Invalid filename — only letters, numbers, dots, hyphens, underscores allowed.");
-                    return;
-                }
-                this.pasteRawToClassicInstance(target.name, `/chat load ${filename}`);
-                await data.respond(`✅ Sent \`/chat load ${filename}\` to ${target.name}`);
-            }
-            else if (data.command === "compact") {
-                const target = this.routing.resolve(data.channelId);
-                if (!target) {
-                    await data.respond("No active agent in this channel.");
+                    await data.respond(t("filename.invalid"));
                     return;
                 }
-                const result = await this.topicCommands.sendCompact(target.name);
-                await data.respond(result);
+                this.pasteRawToClassicInstance(name, `/chat load ${filename}`);
+                await data.respond(t("save.sent", `/chat load ${filename}`, name));
             }
             else if (data.command === "cancel") {
-                const target = this.routing.resolve(data.channelId);
-                if (!target) {
-                    await data.respond("No active agent in this channel.");
+                const name = this.resolveSlashTarget(data.channelId, adapterId);
+                if (!name) {
+                    await data.respond(t("classic.no_agent"));
                     return;
                 }
-                const ok = this.cancelInstance(target.name);
-                await data.respond(ok ? `🛑 Sent cancel to ${target.name}.` : `❌ ${target.name} not running.`);
+                const ok = this.cancelInstance(name);
+                await data.respond(ok ? t("cancel.sent", name) : t("cancel.not_running", name));
             }
             else if (data.command === "ctx") {
-                const target = this.routing.resolve(data.channelId);
-                if (!target) {
-                    await data.respond("No active agent in this channel.");
+                const name = this.resolveSlashTarget(data.channelId, adapterId);
+                if (!name) {
+                    await data.respond(t("classic.no_agent"));
                     return;
                 }
                 // Single source of truth (statusline.json + robust tmux pane fallback).
-                await data.respond(await this.topicCommands.getCtxText(target.name));
+                await data.respond(await this.topicCommands.getCtxText(name));
             }
             else if (data.command === "collab") {
+                // Classic no longer lives in the routing engine, so a routing hit here is
+                // always a fleet-topic instance.
                 const collabTarget2 = this.routing.resolve(data.channelId);
-                if (collabTarget2 && collabTarget2.kind !== "classic") {
+                if (collabTarget2) {
                     const allowed = this.fleetConfig?.channel?.access?.allowed_users ?? [];
                     if (allowed.length > 0 && !allowed.some(u => String(u) === String(data.userId))) {
-                        await data.respond("⛔ Not authorized");
+                        await data.respond(t("not_authorized"));
                         return;
                     }
                     const isCollab = this.toggleFleetCollab(collabTarget2.name);
-                    await data.respond(isCollab ? "🤝 Collaboration mode **ON** — bot/webhook messages reach the agent." : "💬 Collaboration mode **OFF**");
+                    await data.respond(isCollab ? t("collab.on") : t("collab.off"));
                     return;
                 }
                 if (!this.classicChannels?.isAdmin(data.userId)) {
-                    await data.respond("⛔ This command requires admin access.");
+                    await data.respond(t("admin.required"));
                     return;
                 }
-                if (!this.classicChannels.isClassicChannel(data.channelId)) {
-                    await data.respond("No active agent in this channel. Use `/start` first.");
+                if (!this.classicChannels.isClassicChannel(data.channelId, adapterId)) {
+                    await data.respond(t("classic.no_agent_start"));
                     return;
                 }
-                const newState = this.classicChannels.toggleCollab(data.channelId);
+                const newState = this.classicChannels.toggleCollab(data.channelId, adapterId);
                 await data.respond(newState
-                    ? "🤝 Collaboration mode **ON** — @mention this bot to trigger the agent. Other bot messages are visible."
-                    : "💬 Collaboration mode **OFF** — use `/chat` to talk to the agent.");
+                    ? t("collab.on.classic")
+                    : 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("⛔ Not authorized");
+                    await data.respond(t("not_authorized"));
                     return;
                 }
-                await data.respond("📦 Updating AgEnD... Fleet will restart automatically.");
+                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";
@@ -1221,7 +1305,7 @@ export class FleetManager {
             else if (data.command === "doctor") {
                 const allowed = this.fleetConfig?.channel?.access?.allowed_users ?? [];
                 if (allowed.length > 0 && !allowed.some(u => String(u) === String(data.userId))) {
-                    await data.respond("⛔ Not authorized");
+                    await data.respond(t("not_authorized"));
                     return;
                 }
                 try {
@@ -1243,22 +1327,36 @@ export class FleetManager {
             else if (data.command === "sysinfo") {
                 await data.respond(this.topicCommands.getSysInfoText());
             }
+            else if (data.command === "dashboard") {
+                // Reply is ephemeral (adapter defers non-chat commands ephemerally), so
+                // the web-token-bearing URLs are only visible to the caller.
+                const allowed = this.fleetConfig?.channel?.access?.allowed_users ?? [];
+                if (allowed.length === 0) {
+                    await data.respond(t("dashboard.disabled"));
+                    return;
+                }
+                if (!allowed.some(u => String(u) === String(data.userId))) {
+                    await data.respond(t("not_authorized"));
+                    return;
+                }
+                await data.respond(this.topicCommands.getDashboardText());
+            }
             else if (data.command === "restart") {
                 const allowed = this.fleetConfig?.channel?.access?.allowed_users ?? [];
                 if (allowed.length > 0 && !allowed.some(u => String(u) === String(data.userId))) {
-                    await data.respond("⛔ Not authorized");
+                    await data.respond(t("not_authorized"));
                     return;
                 }
-                await data.respond("🔄 Graceful restart — waiting for instances to idle...");
+                await data.respond(t("restart.graceful"));
                 process.kill(process.pid, "SIGUSR2");
             }
             else if (data.command === "compact") {
-                const target = this.routing.resolve(data.channelId);
-                if (!target) {
-                    await data.respond("No active agent in this channel.");
+                const name = this.resolveSlashTarget(data.channelId, adapterId);
+                if (!name) {
+                    await data.respond(t("classic.no_agent"));
                     return;
                 }
-                const result = await this.topicCommands.sendCompact(target.name);
+                const result = await this.topicCommands.sendCompact(name);
                 await data.respond(result);
             }
         }, this.logger, `adapter[${adapterId}].slash_command`));
@@ -1276,7 +1374,7 @@ export class FleetManager {
             }
         }, this.logger, `adapter[${adapterId}].started`));
         adapter.on("new_group_detected", safeHandler((data) => {
-            const adminMsg = `🆕 Bot added to new server:\n• Name: ${data.groupTitle}\n• ID: ${data.groupId}\n• Platform: ${data.source}\n\nTo allow: add \`${data.groupId}\` to classicBot.yaml \`allowed_guilds\``;
+            const adminMsg = t("alert.bot_added", data.groupTitle, data.groupId, data.source);
             const generalId = this.findGeneralInstance(adapterId);
             if (generalId)
                 this.notifyInstanceTopic(generalId, adminMsg);
@@ -1481,8 +1579,17 @@ export class FleetManager {
         // Routing (by topic/channel) and reply-adapter selection (by channel_id
         // binding) are adapter-independent, so it's safe to let whichever adapter
         // arrives first handle it.
+        //
+        // EXCEPTION — classic channels with same-channel multi-bot: two bots may own
+        // separate agents in one channel, so each bot must process its OWN copy of
+        // the message (the @mention filter downstream decides who actually forwards).
+        // Key the dedup per-adapter there so a sibling bot's copy isn't dropped.
         if (msg.messageId) {
-            const dedupKey = `${msg.source}:${msg.chatId}:${msg.messageId}`;
+            const classicCid = msg.threadId || msg.chatId;
+            const isClassicMsg = this.classicChannels?.hasChannel(classicCid) ?? false;
+            const dedupKey = isClassicMsg
+                ? `${msg.source}:${msg.chatId}:${msg.messageId}:${msg.adapterId ?? ""}`
+                : `${msg.source}:${msg.chatId}:${msg.messageId}`;
             if (this.recentMessageIds.has(dedupKey)) {
                 this.logger.debug({ dedupKey, adapterId: msg.adapterId }, "Duplicate inbound across adapters — skipping");
                 return;
@@ -1509,21 +1616,25 @@ export class FleetManager {
                     return;
                 // Fall through to TG classic handling below
             }
+            else if (this.classicChannels?.hasChannel(threadId)) {
+                // Classic channel (per-bot): bot messages only when THIS bot owns an
+                // agent here and collab is on for it.
+                const classicName = this.classicChannels.getInstanceByChannel(threadId, msg.adapterId);
+                if (!classicName)
+                    return;
+                if (!this.classicChannels.isCollab(threadId, msg.adapterId))
+                    return;
+                // Fall through to channel handling
+            }
             else {
                 const target = this.routing.resolve(threadId);
                 if (!target)
                     return;
-                if (target.kind === "classic") {
-                    if (!this.classicChannels?.isCollab(threadId))
-                        return;
-                }
-                else {
-                    // Fleet topic: allow if collab enabled OR access mode is open
-                    const channelCfg = this.getChannelConfig(msg.adapterId);
-                    const isOpen = channelCfg?.access?.mode === "open";
-                    if (!isOpen && !this.collabInstances.has(target.name))
-                        return;
-                }
+                // Fleet topic: allow if collab enabled OR access mode is open
+                const channelCfg = this.getChannelConfig(msg.adapterId);
+                const isOpen = channelCfg?.access?.mode === "open";
+                if (!isOpen && !this.collabInstances.has(target.name))
+                    return;
                 // Fall through to channel handling
             }
         }
@@ -1533,9 +1644,10 @@ export class FleetManager {
             const adapterGroupId = String(this.getChannelConfig(msg.adapterId)?.group_id ?? "");
             const isTelegramClassicCandidate = msg.source === "telegram" && msg.chatId !== adapterGroupId && !threadId;
             if (!isTelegramClassicCandidate) {
-                const target = threadId ? this.routing.resolve(threadId) : undefined;
-                this.logger.info({ userId: msg.userId, threadId, targetKind: target?.kind, targetName: target?.name }, "Access DENIED for non-allowed user");
-                if (!target || target.kind !== "classic")
+                // Classic channels are open to all; check per-bot ownership (or fleet topic).
+                const isClassic = !!(threadId && this.classicChannels?.hasChannel(threadId));
+                this.logger.info({ userId: msg.userId, threadId, isClassic }, "Access DENIED for non-allowed user");
+                if (!isClassic)
                     return;
             }
         }
@@ -1580,9 +1692,9 @@ export class FleetManager {
                         if (!this.classicChannels.isUserAllowed(msg.userId)) {
                             const generalId = this.findGeneralInstance(msg.adapterId);
                             if (generalId) {
-                                this.notifyInstanceTopic(generalId, `🆕 Unauthorized user tried /start in private chat:\n• Name: ${msg.username}\n• ID: ${msg.userId}\n• Platform: ${msg.source}\n\nTo allow: add \`${msg.userId}\` to classicBot.yaml \`allowed_users\``);
+                                this.notifyInstanceTopic(generalId, t("alert.unauth_user_private", msg.username, msg.userId, msg.source));
                             }
-                            await msgAdapter?.sendText(chatId, "⛔ You are not in the allowed users list.");
+                            await msgAdapter?.sendText(chatId, t("classic.not_allowed_user"));
                             return;
                         }
                     }
@@ -1590,136 +1702,135 @@ export class FleetManager {
                         if (!this.classicChannels.isGroupAllowed(chatId)) {
                             // Notify admin about new group wanting access
                             const groupTitle = msg.chatTitle || chatId;
-                            const adminMsg = `🆕 New group detected:\n• Name: ${groupTitle}\n• ID: ${chatId}\n• User: ${msg.username} (${msg.userId})\n• Platform: ${msg.source}\n\nTo allow: add \`${chatId}\` to classicBot.yaml \`allowed_guilds\``;
+                            const adminMsg = t("alert.new_group", groupTitle, chatId, msg.username, msg.userId, msg.source);
                             const generalId = this.findGeneralInstance(msg.adapterId);
                             if (generalId) {
                                 this.notifyInstanceTopic(generalId, adminMsg);
                             }
-                            await msgAdapter?.sendText(chatId, "⏳ Access requested. Waiting for admin approval.");
+                            await msgAdapter?.sendText(chatId, t("classic.access_requested"));
                             return;
                         }
                         if (!this.classicChannels.isAdmin(msg.userId)) {
-                            await msgAdapter?.sendText(chatId, "⛔ Only admins can start agents. Ask an admin to /start.");
+                            await msgAdapter?.sendText(chatId, t("classic.admin_only_start"));
                             const generalId = this.findGeneralInstance(msg.adapterId);
                             if (generalId) {
-                                this.notifyInstanceTopic(generalId, `🔑 User wants to /start but is not admin:\n• Name: ${msg.username}\n• ID: ${msg.userId}\n• Platform: ${msg.source}\n• Group: ${chatId}\n\nTo approve: add \`${msg.userId}\` to classicBot.yaml \`admin_users\``);
+                                this.notifyInstanceTopic(generalId, t("alert.start_not_admin", msg.username, msg.userId, msg.source, chatId));
                             }
                             return;
                         }
                     }
                     const channelName = msg.username || chatId;
-                    const reply = await this.handleClassicStart(chatId, channelName, msg.userId);
-                    if (msg.adapterId)
-                        this.bindInstanceAdapter(classicInstanceName(sanitizeInstanceName(channelName || chatId), chatId), msg.adapterId, true);
+                    // handleClassicStart binds the instance to this adapter authoritatively.
+                    const reply = await this.handleClassicStart(chatId, channelName, msg.userId, undefined, msg.adapterId);
                     await msgAdapter?.sendText(chatId, reply);
                     return;
                 }
                 // Handle /stop command
                 if (text === "/stop" || text.startsWith("/stop ")) {
                     if (!this.classicChannels.isAdmin(msg.userId)) {
-                        await msgAdapter?.sendText(chatId, "⛔ Only admins can stop agents.");
+                        await msgAdapter?.sendText(chatId, t("classic.admin_only_stop"));
                         const generalId = this.findGeneralInstance(msg.adapterId);
                         if (generalId) {
-                            this.notifyInstanceTopic(generalId, `🔑 User wants to /stop but is not admin:\n• Name: ${msg.username}\n• ID: ${msg.userId}\n• Platform: ${msg.source}\n• Group: ${chatId}\n\nTo approve: add \`${msg.userId}\` to classicBot.yaml \`admin_users\``);
+                            this.notifyInstanceTopic(generalId, t("alert.stop_not_admin", msg.username, msg.userId, msg.source, chatId));
                         }
                         return;
                     }
-                    const reply = await this.handleClassicStop(chatId);
+                    const reply = await this.handleClassicStop(chatId, msg.adapterId);
                     await msgAdapter?.sendText(chatId, reply);
                     return;
                 }
                 // Handle /compact command (admin only)
                 if (text === "/compact" || text.startsWith("/compact@")) {
                     if (!this.classicChannels.isAdmin(msg.userId)) {
-                        await msgAdapter?.sendText(chatId, "⛔ /compact requires admin access.");
+                        await msgAdapter?.sendText(chatId, t("cmd.admin_required", "/compact"));
                         return;
                     }
-                    const compactTarget = this.routing.resolve(chatId);
-                    if (!compactTarget || compactTarget.kind !== "classic") {
-                        await msgAdapter?.sendText(chatId, "No active agent. Use /start first.");
+                    const compactName = this.classicChannels.getInstanceByChannel(chatId, msg.adapterId);
+                    if (!compactName) {
+                        await msgAdapter?.sendText(chatId, t("classic.no_agent_start"));
                         return;
                     }
-                    const result = await this.topicCommands.sendCompact(compactTarget.name);
+                    const result = await this.topicCommands.sendCompact(compactName);
                     await msgAdapter?.sendText(chatId, result);
                     return;
                 }
                 // Handle /cancel command
                 if (text === "/cancel" || text.startsWith("/cancel@")) {
-                    const cancelTarget = this.routing.resolve(chatId);
-                    if (!cancelTarget || cancelTarget.kind !== "classic") {
-                        await msgAdapter?.sendText(chatId, "No active agent. Use /start first.");
+                    const cancelName = this.classicChannels.getInstanceByChannel(chatId, msg.adapterId);
+                    if (!cancelName) {
+                        await msgAdapter?.sendText(chatId, t("classic.no_agent_start"));
                         return;
                     }
-                    const ok = this.cancelInstance(cancelTarget.name);
-                    await msgAdapter?.sendText(chatId, ok ? `🛑 已送出取消給 ${cancelTarget.name}。` : `❌ ${cancelTarget.name} 未在執行。`);
+                    const ok = this.cancelInstance(cancelName);
+                    await msgAdapter?.sendText(chatId, ok ? `🛑 已送出取消給 ${cancelName}。` : `❌ ${cancelName} 未在執行。`);
                     return;
                 }
                 // Handle /ctx command
                 if (text === "/ctx" || text.startsWith("/ctx@")) {
-                    const ctxTarget = this.routing.resolve(chatId);
-                    if (!ctxTarget || ctxTarget.kind !== "classic") {
-                        await msgAdapter?.sendText(chatId, "No active agent. Use /start first.");
+                    const ctxName = this.classicChannels.getInstanceByChannel(chatId, msg.adapterId);
+                    if (!ctxName) {
+                        await msgAdapter?.sendText(chatId, t("classic.no_agent_start"));
                         return;
                     }
-                    const reply = await this.topicCommands.getCtxText(ctxTarget.name);
+                    const reply = await this.topicCommands.getCtxText(ctxName);
                     await msgAdapter?.sendText(chatId, reply);
                     return;
                 }
                 // Handle /save command (admin only)
                 if (text === "/save" || text.startsWith("/save ") || text.startsWith("/save@")) {
                     if (!this.classicChannels.isAdmin(msg.userId)) {
-                        await msgAdapter?.sendText(chatId, "⛔ /save requires admin access.");
+                        await msgAdapter?.sendText(chatId, t("cmd.admin_required", "/save"));
                         return;
                     }
-                    const saveTarget = this.routing.resolve(chatId);
-                    if (!saveTarget || saveTarget.kind !== "classic") {
-                        await msgAdapter?.sendText(chatId, "No active agent. Use /start first.");
+                    const saveName = this.classicChannels.getInstanceByChannel(chatId, msg.adapterId);
+                    if (!saveName) {
+                        await msgAdapter?.sendText(chatId, t("classic.no_agent_start"));
                         return;
                     }
                     const filename = parseSaveFilename(text);
                     if (!filename) {
-                        await msgAdapter?.sendText(chatId, "Usage: /save <filename>");
+                        await msgAdapter?.sendText(chatId, t("save.usage"));
                         return;
                     }
                     if (!SAVE_FILENAME_RE.test(filename)) {
-                        await msgAdapter?.sendText(chatId, "⛔ Invalid filename — only letters, numbers, dots, hyphens, underscores allowed.");
+                        await msgAdapter?.sendText(chatId, t("filename.invalid"));
                         return;
                     }
-                    const backend = this.classicChannels.getBackendByInstance(saveTarget.name, this.fleetConfig?.defaults?.backend);
+                    const backend = this.classicChannels.getBackendByInstance(saveName, this.fleetConfig?.defaults?.backend);
                     const cmd = saveCommandForBackend(backend, filename);
                     if (!cmd) {
                         await msgAdapter?.sendText(chatId, SAVE_UNSUPPORTED_MSG);
                         return;
                     }
-                    this.pasteRawToClassicInstance(saveTarget.name, cmd);
-                    await msgAdapter?.sendText(chatId, `✅ Sent \`${cmd}\` to ${saveTarget.name}`);
+                    this.pasteRawToClassicInstance(saveName, cmd);
+                    await msgAdapter?.sendText(chatId, t("save.sent", cmd, saveName));
                     return;
                 }
-                // Route to classic channel if registered
-                const target = this.routing.resolve(chatId);
-                if (target?.kind === "classic") {
+                // Route to classic channel if this bot has an agent here (per-bot).
+                const classicName = this.classicChannels.getInstanceByChannel(chatId, msg.adapterId);
+                if (classicName) {
                     if (msg.adapterId)
-                        this.bindInstanceAdapter(target.name, msg.adapterId, true);
+                        this.bindInstanceAdapter(classicName, msg.adapterId, true);
                     // TG ClassicBot: group requires @mention, private chat forwards directly.
                     if (!isPrivateChat && !isBotMentioned) {
                         // No trigger: save attachments + react, log, but don't forward to agent
                         const syntheticMsg = { ...msg, threadId: chatId, text: rawText.startsWith("/") ? "" : rawText };
-                        await this.handleClassicChannelMessage(target.name, syntheticMsg);
+                        await this.handleClassicChannelMessage(classicName, syntheticMsg);
                         return;
                     }
                     // Strip @bot from text and forward as /chat
                     const cleanText = botUser ? text.replace(new RegExp(`@${botUser}`, "gi"), "").trim() : text;
                     if (cleanText.startsWith("/raw") && !this.classicChannels.isAdmin(msg.userId)) {
-                        await msgAdapter?.sendText(chatId, "⛔ /raw requires admin access.");
+                        await msgAdapter?.sendText(chatId, t("cmd.admin_required", "/raw"));
                         return;
                     }
                     const syntheticMsg = { ...msg, threadId: chatId, text: `/chat ${cleanText}` };
-                    await this.handleClassicChannelMessage(target.name, syntheticMsg);
+                    await this.handleClassicChannelMessage(classicName, syntheticMsg);
                     return;
                 }
                 // Handle @bot without active agent
                 if (isBotMentioned) {
-                    await msgAdapter?.sendText(chatId, "No active agent. Use /start first.");
+                    await msgAdapter?.sendText(chatId, t("classic.no_agent_start"));
                     return;
                 }
                 // Unregistered private chat: ignore (don't fall through to General)
@@ -1739,9 +1850,12 @@ export class FleetManager {
                 if (msg.adapterId)
                     this.bindInstanceAdapter(generalInstance, msg.adapterId, true);
                 const inboundAdapter = this.worlds.get(msg.adapterId ?? "")?.adapter ?? this.adapter;
-                // React immediately — before any other API calls
+                // React immediately — before any other API calls. Use the adapter BOUND to
+                // the instance (not whichever same-guild bot received the event first) so
+                // exactly the owning bot reacts — no duplicate 👀 from a sibling bot.
                 if (msg.chatId && msg.messageId) {
-                    inboundAdapter.react(msg.threadId ?? msg.chatId, msg.messageId, "👀")
+                    const reactAdapter = this.getAdapterForInstance(generalInstance) ?? inboundAdapter;
+                    reactAdapter.react(msg.threadId ?? msg.chatId, msg.messageId, "👀")
                         .catch(e => this.logger.debug({ err: e.message }, "Auto-react failed"));
                 }
                 this.warnIfRateLimited(generalInstance, msg);
@@ -1777,6 +1891,18 @@ export class FleetManager {
             }
             return;
         }
+        // Classic channels resolve per-bot (same-channel multi-bot) — a channel can
+        // host two bots' agents. If this channel is classic but THIS bot has no
+        // agent here, a sibling bot owns it; skip rather than misroute to it.
+        if (this.classicChannels?.hasChannel(threadId)) {
+            const classicName = this.classicChannels.getInstanceByChannel(threadId, msg.adapterId);
+            if (!classicName)
+                return;
+            if (msg.adapterId)
+                this.bindInstanceAdapter(classicName, msg.adapterId, true);
+            await this.handleClassicChannelMessage(classicName, msg);
+            return;
+        }
         const target = this.routing.resolve(threadId);
         if (!target) {
             // Only show unbound message for actual forum topics (same group, has threadId)
@@ -1808,9 +1934,12 @@ export class FleetManager {
         if (msg.adapterId)
             this.bindInstanceAdapter(instanceName, msg.adapterId, true);
         const inboundAdapter = this.worlds.get(msg.adapterId ?? "")?.adapter ?? this.adapter;
-        // React immediately — before any other Discord API calls
+        // React immediately — before any other Discord API calls. Use the adapter
+        // BOUND to the instance (not whichever same-guild bot received the event
+        // first) so exactly the owning bot reacts — no duplicate 👀 from a sibling.
         if (msg.chatId && msg.messageId) {
-            inboundAdapter.react(this.reactTarget(msg), msg.messageId, "👀")
+            const reactAdapter = this.getAdapterForInstance(instanceName) ?? inboundAdapter;
+            reactAdapter.react(this.reactTarget(msg), msg.messageId, "👀")
                 .catch(e => this.logger.debug({ err: e.message }, "Auto-react failed"));
         }
         // These may hit Discord API (topic icon, archive) — do after react
@@ -1935,7 +2064,7 @@ export class FleetManager {
                     ts: new Date().toISOString(),
                 });
                 // Log bot reply to classic instance chat-log
-                const isClassic = [...this.routing.entries()].some(([, t]) => t.kind === "classic" && t.name === instanceName);
+                const isClassic = this.classicChannels?.getChannelIdByInstance(instanceName) !== undefined;
                 if (isClassic) {
                     ClassicChannelManager.logMessage(instanceName, "bot", args.text ?? "", new Date());
                 }
@@ -1995,7 +2124,7 @@ export class FleetManager {
                 five_hour_pct: rl.five_hour_pct,
             });
             this.webhookEmitter?.emit("schedule_deferred", target, { schedule_id: id, label, five_hour_pct: rl.five_hour_pct });
-            this.notifyInstanceTopic(target, `⏳ Schedule "${label ?? id}" deferred — rate limit at ${rl.five_hour_pct}%`);
+            this.notifyInstanceTopic(target, t("schedule.deferred", label ?? id, rl.five_hour_pct));
             this.logger.info({ target, scheduleId: id, rateLimitPct: rl.five_hour_pct }, "Schedule deferred due to rate limit");
             return;
         }
@@ -2482,6 +2611,8 @@ export class FleetManager {
             // Preserve all optional user-configured fields so saveFleetConfig() never silently drops them
             if (inst.general_topic)
                 serialized.general_topic = true;
+            if (inst.display_name)
+                serialized.display_name = inst.display_name;
             if (inst.channel_id)
                 serialized.channel_id = inst.channel_id;
             if (inst.description)
@@ -2554,15 +2685,17 @@ export class FleetManager {
     startStatuslineWatcher(name) {
         this.statuslineWatcher.watch(name);
     }
-    reactMessageStatus(chatId, messageId, emoji) {
-        // Find the adapter that owns this chatId (check all adapters, not just primary)
-        for (const [, w] of this.worlds) {
-            if (w.type === "discord") {
-                w.react(chatId, messageId, emoji)
-                    .catch(e => this.logger.debug({ err: e.message }, "Message status react failed"));
-                return;
-            }
-        }
+    reactMessageStatus(instanceName, chatId, messageId, emoji) {
+        // React via the adapter BOUND to this instance — NOT the first discord world.
+        // Otherwise, in a same-channel/same-guild multi-bot setup, the inbound 👀
+        // (bound bot) and the delivery/confirm reactions (some other bot) come from
+        // different bots, leaving a duplicate 👀 that never turns into ✅.
+        const adapter = this.getAdapterForInstance(instanceName) ?? this.adapter;
+        // Status reactions are Discord-only (TG/others use the inbound react path).
+        if (!adapter || adapter.type !== "discord")
+            return;
+        adapter.react(chatId, messageId, emoji)
+            .catch(e => this.logger.debug({ err: e.message }, "Message status react failed"));
     }
     // ── Model failover ──────────────────────────────────────────────────────
     static FAILOVER_TRIGGER_PCT = 90;
@@ -2611,7 +2744,7 @@ export class FleetManager {
         this.collabInstances.add(instanceName);
         return true;
     }
-    notifyInstanceTopic(instanceName, text) {
+    notifyInstanceTopic(instanceName, text, extraOpts) {
         const adapter = this.getAdapterForInstance(instanceName) ?? this.adapter;
         if (!adapter)
             return;
@@ -2620,21 +2753,20 @@ export class FleetManager {
         // Fleet topic instance
         const threadId = this.fleetConfig?.instances[instanceName]?.topic_id;
         if (threadId != null && groupId) {
-            adapter.sendText(String(groupId), text, { threadId: String(threadId) })
+            adapter.sendText(String(groupId), text, { threadId: String(threadId), ...extraOpts })
                 .catch(e => this.logger.warn({ err: e, instanceName }, "Failed to send instance topic notification"));
             return;
         }
-        // Classic instance: find chatId from routing table
-        for (const [chatId, target] of this.routing.entries()) {
-            if (target.kind === "classic" && target.name === instanceName) {
-                adapter.sendText(chatId, text)
-                    .catch(e => this.logger.warn({ err: e, instanceName }, "Failed to send classic notification"));
-                return;
-            }
+        // Classic instance: find its channelId from the classic manager
+        const classicChatId = this.classicChannels?.getChannelIdByInstance(instanceName);
+        if (classicChatId) {
+            adapter.sendText(classicChatId, text, extraOpts)
+                .catch(e => this.logger.warn({ err: e, instanceName }, "Failed to send classic notification"));
+            return;
         }
         // Fallback: send to group without threadId
         if (groupId) {
-            adapter.sendText(String(groupId), text)
+            adapter.sendText(String(groupId), text, extraOpts)
                 .catch(e => this.logger.warn({ err: e, instanceName }, "Failed to send notification (no topic)"));
         }
     }
@@ -2647,19 +2779,23 @@ export class FleetManager {
      * Picks the backend-appropriate command (kiro → /chat save, claude → /export);
      * unsupported backends get a clear error. Routes via classic paste or fleet IPC.
      */
-    async handleSlashSave(data) {
+    async handleSlashSave(data, adapterId) {
         if (!this.classicChannels?.isAdmin(data.userId)) {
-            await data.respond("⛔ This command requires admin access.");
+            await data.respond(t("admin.required"));
             return;
         }
-        const target = this.routing.resolve(data.channelId);
+        // Classic resolves per-bot (same-channel multi-bot); otherwise a fleet topic.
+        const classicName = this.classicChannels.getInstanceByChannel(data.channelId, adapterId);
+        const target = classicName
+            ? { kind: "classic", name: classicName }
+            : this.routing.resolve(data.channelId);
         if (!target) {
-            await data.respond("No active agent in this channel. Use `/start` first.");
+            await data.respond(t("classic.no_agent_start"));
             return;
         }
         const filename = data.options?.filename ?? "";
         if (!SAVE_FILENAME_RE.test(filename)) {
-            await data.respond("⛔ Invalid filename — only letters, numbers, dots, hyphens, underscores allowed.");
+            await data.respond(t("filename.invalid"));
             return;
         }
         const backend = target.kind === "classic"
@@ -2678,7 +2814,7 @@ export class FleetManager {
         else {
             this.instanceIpcClients.get(target.name)?.send({ type: "raw_paste", content: cmd });
         }
-        await data.respond(`✅ Sent \`${cmd}\` to ${target.name}`);
+        await data.respond(t("save.sent", cmd, target.name));
     }
     /** Whether the instance currently has at least one live cancel button. */
     hasCancelButton(instanceName) {
@@ -2707,13 +2843,8 @@ export class FleetManager {
             threadId = String(topicId);
         }
         else {
-            // Classic instance: chatId from the routing table.
-            for (const [cid, target] of this.routing.entries()) {
-                if (target.kind === "classic" && target.name === instanceName) {
-                    chatId = cid;
-                    break;
-                }
-            }
+            // Classic instance: channelId from the classic manager.
+            chatId = this.classicChannels?.getChannelIdByInstance(instanceName);
             // General / flat fallback: post to the group (no thread).
             if (!chatId && groupId)
                 chatId = String(groupId);
@@ -2725,7 +2856,7 @@ export class FleetManager {
                 type: "cancel",
                 instanceName,
                 message: "👀 處理中…",
-                choices: [{ id: `cancel:${instanceName}`, label: "🛑 取消" }],
+                choices: [{ id: `cancel:${instanceName}`, label: t("cancel.button") }],
             }, threadId ? { threadId } : undefined);
             // A concurrent sendCancelButton for the same instance may have posted its
             // own button while we awaited notifyAlert. Retire any other buttons for
@@ -3196,7 +3327,7 @@ When users create specialized instances, suggest these configurations:
     async handleClassicChannelMessage(instanceName, msg) {
         const text = msg.text ?? "";
         const channelId = msg.threadId ?? msg.chatId;
-        const isCollabMode = this.classicChannels?.isCollab(channelId) ?? false;
+        const isCollabMode = this.classicChannels?.isCollab(channelId, msg.adapterId) ?? false;
         // Handle /ctx in classic mode — always, regardless of collab mode
         if (text === "/ctx" || text.startsWith("/ctx@")) {
             const reply = await this.topicCommands.getCtxText(instanceName);
@@ -3223,8 +3354,15 @@ When users create specialized instances, suggest these configurations:
                     : "");
             ClassicChannelManager.logMessage(instanceName, msg.username, text + collabAttachTag, msg.timestamp, msg.replyToText);
             this.logger.info({ instanceName, user: msg.username, textLen: text.length, attachments: msg.attachments?.length ?? 0, source: msg.source }, "Collab mode message");
-            // Check for @mention trigger: must be exact <@BOT_USER_ID>, not @everyone/@here
-            const adapterBotUserId = this.worlds.get(msg.adapterId ?? "")?.botUserId ?? this.botUserId;
+            // Check for @mention trigger: must be exact <@BOT_USER_ID>, not @everyone/@here.
+            // Each bot matches ONLY its own id. A secondary bot must NOT fall back to the
+            // process-wide botUserId (the primary's) — otherwise, in a same-channel
+            // multi-bot setup, an @mention of the primary would also match the secondary
+            // and BOTH bots would react 👀 and forward. Only the primary adapter may use
+            // the fallback.
+            const mentionWorld = this.worlds.get(msg.adapterId ?? "");
+            const isPrimaryAdapter = !mentionWorld || mentionWorld.adapter === this.adapter;
+            const adapterBotUserId = mentionWorld?.botUserId ?? (isPrimaryAdapter ? this.botUserId : undefined);
             const mentionTag = adapterBotUserId ? `<@${adapterBotUserId}>` : null;
             const isMentioned = mentionTag && text.includes(mentionTag);
             if (!isMentioned) {
@@ -3402,7 +3540,11 @@ When users create specialized instances, suggest these configurations:
     }
     /** Forward a message to a classic channel instance with chat log context */
     async forwardToClassicInstance(instanceName, text, msg, extraMeta) {
-        const contextLines = this.classicChannels?.getContextLines(msg.chatId) ?? 5;
+        // Resolve the channel/adapter from the instance itself so per-channel context
+        // config is correct even for a same-channel second bot.
+        const ctxAdapterId = this.classicChannels?.getAdapterIdByInstance(instanceName);
+        const ctxChannelId = this.classicChannels?.getChannelIdByInstance(instanceName) ?? msg.chatId;
+        const contextLines = this.classicChannels?.getContextLines(ctxChannelId, ctxAdapterId) ?? 5;
         const logContext = this.getRecentChatLog(instanceName, contextLines);
         const fullText = logContext
             ? `[Chat log for context]\n${logContext}\n\n[User message]\n${text}`
@@ -3488,44 +3630,51 @@ When users create specialized instances, suggest these configurations:
         await this.startInstance(instanceName, config, topicMode);
     }
     /** Handle /start slash command — register classic channel */
-    async handleClassicStart(channelId, channelName, userId, guildId) {
+    async handleClassicStart(channelId, channelName, userId, guildId, adapterId) {
         if (!this.classicChannels)
             return "Classic channel manager not initialized.";
         if (guildId && !this.classicChannels.isGuildAllowed(guildId)) {
             const generalId = this.findGeneralInstance();
             if (generalId) {
-                this.notifyInstanceTopic(generalId, `🆕 Unauthorized guild tried /start:\n• Guild ID: ${guildId}\n• User: ${userId}\n• Platform: discord\n\nTo allow: add \`${guildId}\` to classicBot.yaml \`allowed_guilds\``);
+                this.notifyInstanceTopic(generalId, t("alert.unauth_guild", guildId, userId));
             }
-            return "⛔ This server is not in the allowed guilds list.";
+            return t("classic.not_authorized_guild");
         }
-        if (this.classicChannels.isClassicChannel(channelId))
-            return "This channel already has an active agent. Use /chat to talk.";
+        // Per-bot check: a second bot may /start in the same channel (own agent).
+        if (this.classicChannels.isClassicChannel(channelId, adapterId))
+            return t("classic.already_active");
+        // Classic no longer lives in the routing engine, so this only guards against
+        // a fleet topic-mode instance colliding with the channel.
         if (this.routing.resolve(channelId))
-            return "This channel is already bound to a topic-mode instance.";
-        const instanceName = classicInstanceName(sanitizeInstanceName(channelName || channelId), channelId);
-        this.classicChannels.register(channelId, instanceName, channelName || channelId, userId);
-        this.routing.register(channelId, { kind: "classic", name: instanceName });
-        await this.startClassicInstance(instanceName, this.classicChannels.getBackend(channelId, this.fleetConfig?.defaults?.backend), this.classicChannels.getPreTaskCommand(channelId), this.classicChannels.getModel(channelId, this.fleetConfig?.defaults?.model));
+            return t("classic.topic_bound");
+        const instanceName = this.classicChannels.deriveInstanceName(channelName || channelId, channelId, adapterId);
+        this.classicChannels.register(channelId, adapterId, instanceName, channelName || channelId, userId);
+        // Bind this classic instance to the bot that started it (authoritative), so
+        // replies/cancel go out through that bot even though every same-guild bot
+        // also sees the channel's messages.
+        if (adapterId)
+            this.bindInstanceAdapter(instanceName, adapterId);
+        await this.startClassicInstance(instanceName, this.classicChannels.getBackend(channelId, adapterId, this.fleetConfig?.defaults?.backend), this.classicChannels.getPreTaskCommand(channelId, adapterId), this.classicChannels.getModel(channelId, adapterId, this.fleetConfig?.defaults?.model));
         this.reregisterClassicChannels();
         // Auto-enable collab for Discord classic channels (TG uses @mention directly without collab mode)
-        if (guildId && !this.classicChannels.isCollab(channelId)) {
-            this.classicChannels.toggleCollab(channelId);
+        if (guildId && !this.classicChannels.isCollab(channelId, adapterId)) {
+            this.classicChannels.toggleCollab(channelId, adapterId);
         }
-        this.logger.info({ channelId, instanceName, userId }, "Classic channel started");
-        return `✅ Agent started in this channel. Use \`/chat <message>\` or @mention to talk.`;
+        this.logger.info({ channelId, adapterId, instanceName, userId }, "Classic channel started");
+        return t("classic.started");
     }
     /** Handle /stop slash command — unregister classic channel */
-    async handleClassicStop(channelId) {
+    async handleClassicStop(channelId, adapterId) {
         if (!this.classicChannels)
             return "Classic channel manager not initialized.";
-        const ch = this.classicChannels.unregister(channelId);
+        const ch = this.classicChannels.unregister(channelId, adapterId);
         if (!ch)
-            return "No active agent in this channel.";
-        this.routing.unregister(channelId);
+            return t("classic.no_agent");
+        this.instanceWorldBinding.delete(ch.instanceName);
         await this.stopInstance(ch.instanceName).catch(err => this.logger.warn({ err, instanceName: ch.instanceName }, "Failed to stop classic instance"));
         this.reregisterClassicChannels();
-        this.logger.info({ channelId, instanceName: ch.instanceName }, "Classic channel stopped");
-        return `🛑 Agent stopped in this channel.`;
+        this.logger.info({ channelId, adapterId, instanceName: ch.instanceName }, "Classic channel stopped");
+        return t("classic.stopped");
     }
     async stopAll() {
         this.ipcStoppingInstances.add("__fleet_stopping__");
@@ -3668,7 +3817,7 @@ When users create specialized instances, suggest these configurations:
         this.logger.info(`Full restart: waiting for ${instanceNames.length} instances to idle...`);
         const groupId = this.fleetConfig?.channel?.group_id;
         if (groupId && this.adapter) {
-            await this.adapter.sendText(String(groupId), `🔄 Full restart initiated — waiting for all instances to idle, then reloading process...`)
+            await this.adapter.sendText(String(groupId), t("restart.full_initiated"))
                 .catch(e => this.logger.warn({ err: e }, "Failed to post full restart notification"));
         }
         // Wait for idle with 5-minute timeout
@@ -3779,7 +3928,7 @@ When users create specialized instances, suggest these configurations:
         const generalThreadId = generalName ? this.fleetConfig?.instances[generalName]?.topic_id : undefined;
         const notifyOpts = { threadId: generalThreadId != null ? String(generalThreadId) : undefined };
         if (groupId && this.adapter) {
-            await this.adapter.sendText(String(groupId), `🔄 Graceful restart initiated — waiting for all instances to idle...`, notifyOpts)
+            await this.adapter.sendText(String(groupId), t("restart.graceful_initiated"), notifyOpts)
                 .catch(e => this.logger.warn({ err: e }, "Failed to post restart notification"));
         }
         const IDLE_TIMEOUT_MS = 5 * 60 * 1000;
@@ -3853,7 +4002,7 @@ When users create specialized instances, suggest these configurations:
                 let idx = 0;
                 while (idx < channels.length) {
                     const batch = channels.slice(idx, idx + concurrency);
-                    await Promise.allSettled(batch.map(ch => this.startClassicInstance(ch.instanceName, this.classicChannels.getBackendByInstance(ch.instanceName, fleetBackend)).catch(err => this.logger.warn({ err, instanceName: ch.instanceName }, "Failed to start classic instance"))));
+                    await Promise.allSettled(batch.map(ch => this.startClassicInstance(ch.instanceName, this.classicChannels.getBackendByInstance(ch.instanceName, fleetBackend), this.classicChannels.getPreTaskCommand(ch.channelId, ch.adapterId), this.classicChannels.getModel(ch.channelId, ch.adapterId, this.fleetConfig?.defaults?.model)).catch(err => this.logger.warn({ err, instanceName: ch.instanceName }, "Failed to start classic instance"))));
                     idx += concurrency;
                 }
             }
@@ -3870,8 +4019,8 @@ When users create specialized instances, suggest these configurations:
             const _require2 = createRequire(import.meta.url);
             const agendVersion2 = _require2("../package.json").version ?? "unknown";
             const restartText = failedNames.length === 0
-                ? `Fleet ready. ${started}/${total} instances running. v${agendVersion2}`
-                : `Fleet ready. ${started}/${total} instances running. v${agendVersion2} | Failed: ${failedNames.join(", ")}`;
+                ? t("fleet.ready", started, total, agendVersion2)
+                : t("fleet.ready_with_failed", started, total, agendVersion2, failedNames.join(", "));
             await this.adapter.sendText(String(groupId), restartText, notifyOpts)
                 .catch(e => this.logger.warn({ err: e }, "Failed to post restart completion notification"));
             // Notify each instance's channel — staggered to avoid rate limit storm
@@ -3936,7 +4085,9 @@ When users create specialized instances, suggest these configurations:
             if (target && this.semverGt(target, currentVersion)) {
                 const generalId = this.findGeneralInstance();
                 if (generalId) {
-                    this.notifyInstanceTopic(generalId, `🆕 AgEnD v${target} available (current: v${currentVersion}). Use \`/update\` to upgrade.`);
+                    // 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})`);
                 }
             }
         }
@@ -4100,6 +4251,7 @@ When users create specialized instances, suggest these configurations:
                 res.writeHead(200);
                 res.end(JSON.stringify({
                     ...sysInfo,
+                    version: this.currentVersion,
                     instances: enriched,
                 }));
                 return;
@@ -4206,6 +4358,8 @@ When users create specialized instances, suggest these configurations:
             const url = new URL(req.url ?? "/", `http://localhost:${port}`);
             if (handleViewRequest(req, res, url, this))
                 return;
+            if (handleSettingsRequest(req, res, url, this))
+                return;
             if (handleWebRequest(req, res, url, this))
                 return;
             res.writeHead(404);