@songsid/agend 2.1.4-beta.8 → 2.1.4

package/dist/topic-commands.js

@@ -8,9 +8,10 @@ const execAsync = promisify(exec);
 import { DEFAULT_INSTANCE_CONFIG } from "./config.js";
 import { formatCents } from "./cost-guard.js";
 import { getTmuxSocketName, getTmuxSessionName } from "./paths.js";
-import { t } from "./locale.js";
+import { t, getLocale } from "./locale.js";
 import { clampContextPercent, parseContextPercent, parseTokenContextRatio, } from "./context-percent.js";
-import { GENERAL_PAUSE_ERROR, isGeneralInstance } from "./general-instance.js";
+import { isGeneralInstance } from "./general-instance.js";
+import { backendSupportsSteer } from "./steer-capability.js";
 export { parseContextPercent, parseTokenContextRatio } from "./context-percent.js";
 /** Sanitize a directory name into a valid instance name. Keeps Unicode letters (incl. CJK). */
 export function sanitizeInstanceName(name) {
@@ -19,6 +20,8 @@ export function sanitizeInstanceName(name) {
 }
 /** Allowed filename for /save and /load (no path separators, no shell/inject chars). */
 export const SAVE_FILENAME_RE = /^[\w.-]+$/;
+/** Backends with a native side-question command that does not steer the active turn. */
+export const BTW_SUPPORTED_BACKENDS = new Set(["claude-code"]);
 /**
  * Build the backend-specific session-save command, or null if the backend has no
  * /save equivalent. kiro-cli → `/chat save <name>`; claude-code → `/export <name>.md`.
@@ -36,7 +39,8 @@ export function parseSaveFilename(text) {
     return (m?.[1] ?? "").trim();
 }
 /** Shared message when a backend doesn't support /save. */
-export const SAVE_UNSUPPORTED_MSG = "⚠️ /save is not supported for this backend (only kiro-cli and claude-code)";
+/** @deprecated Prefer t("save.unsupported") at the user-facing call site. */
+export const SAVE_UNSUPPORTED_MSG = "⚠️ /save is not supported for this backend (only Kiro CLI and Claude Code).";
 export function parsePauseWakeCommand(text) {
     const match = text.match(/^\/(pause|wake)(?:@\S+)?(?:\s+(\S+))?$/);
     if (!match)
@@ -103,7 +107,8 @@ export function clearCommandForBackend(backend) {
             return null;
     }
 }
-export const CLEAR_UNSUPPORTED_MSG = "⚠️ Clear not supported for this backend";
+/** @deprecated Prefer t("clear.unsupported") at the user-facing call site. */
+export const CLEAR_UNSUPPORTED_MSG = "⚠️ Clear is not supported for this backend.";
 /**
  * Extract context-usage % from a captured CLI pane. Scans bottom-up so the
  * MOST RECENT prompt wins (a captured scrollback may hold several). Covers the
@@ -137,6 +142,29 @@ export function readStatuslineContextPct(dataDir, instanceName) {
         return null;
     }
 }
+/**
+ * Claude Code's statusline payload reports the model that actually served the
+ * current session. This can differ from fleet.yaml after the CLI rejects a
+ * plan-gated model and keeps using its previous/default model.
+ */
+export function readStatuslineModel(dataDir, instanceName) {
+    try {
+        const statusFile = join(dataDir, "instances", instanceName, "statusline.json");
+        if (!existsSync(statusFile))
+            return null;
+        const data = JSON.parse(readFileSync(statusFile, "utf-8"));
+        const id = typeof data.model?.id === "string" ? data.model.id.trim() : "";
+        const displayName = typeof data.model?.display_name === "string"
+            ? data.model.display_name.trim()
+            : "";
+        if (displayName && id && displayName !== id)
+            return `${displayName} (${id})`;
+        return id || displayName || null;
+    }
+    catch {
+        return null;
+    }
+}
 /** Live-pane scrape used by /ctx, /status Ctx, and /view sidebar. */
 export function scrapePaneContext(instanceName, backend) {
     try {
@@ -270,6 +298,20 @@ export class TopicCommands {
             await this.handleUsageCommand(msg);
             return true;
         }
+        if (text === "/tips" || text.startsWith("/tips ") || text.startsWith("/tips@")) {
+            await this.handleTipsCommand(msg);
+            return true;
+        }
+        if (text === "/login" || text.startsWith("/login ") || text.startsWith("/login@")) {
+            await this.handleLoginCommand(msg);
+            return true;
+        }
+        // Telegram command names cannot contain "-", so the menu registers
+        // /install_cli; accept both spellings as typed text.
+        if (/^\/install[-_]cli(?:@\S+)?(?:\s|$)/.test(text)) {
+            await this.handleInstallCliCommand(msg);
+            return true;
+        }
         if (text === "/update" || text.startsWith("/update@")) {
             await this.handleUpdateCommand(msg);
             return true;
@@ -332,6 +374,13 @@ export class TopicCommands {
         const text = msg.text?.trim();
         if (!text)
             return false;
+        // Tips are informational and should appear where requested, including a
+        // worker topic. This also keeps Telegram text commands aligned with
+        // Discord's channel-local slash-command behavior.
+        if (text === "/tips" || text.startsWith("/tips ") || text.startsWith("/tips@")) {
+            await this.handleTipsCommand(msg);
+            return true;
+        }
         const pauseWake = parsePauseWakeCommand(text);
         if (pauseWake) {
             const adapter = this.getReplyAdapter(msg);
@@ -352,7 +401,7 @@ export class TopicCommands {
                 return true;
             }
             if (pauseWake.action === "pause" && isGeneralInstance(this.ctx.fleetConfig, target)) {
-                await adapter.sendText(msg.chatId, GENERAL_PAUSE_ERROR, { threadId: msg.threadId });
+                await adapter.sendText(msg.chatId, t("general.pause_forbidden"), { threadId: msg.threadId });
                 return true;
             }
             await adapter.sendText(msg.chatId, await this.runPauseWake(target, pauseWake.action), { threadId: msg.threadId });
@@ -379,7 +428,7 @@ export class TopicCommands {
             const level = text.replace(/^\/effort(@\S+)?/, "").trim();
             if (level) {
                 const reply = await this.ctx.applyEffort?.(instanceName, level)
-                    ?? "Effort switching is unavailable.";
+                    ?? t("effort.unsupported", this.effectiveBackend(instanceName));
                 await adapter.sendText(msg.chatId, reply, { threadId: msg.threadId });
             }
             else if (this.ctx.promptEffortMenu) {
@@ -410,7 +459,7 @@ export class TopicCommands {
                     await adapter.sendText(msg.chatId, fallback, { threadId: msg.threadId });
             }
             else {
-                await adapter.sendText(msg.chatId, "Usage: /model <name> — e.g. /model sonnet", { threadId: msg.threadId });
+                await adapter.sendText(msg.chatId, t("model.usage"), { threadId: msg.threadId });
             }
             return true;
         }
@@ -422,6 +471,39 @@ export class TopicCommands {
             await adapter.sendText(msg.chatId, result, { threadId: msg.threadId });
             return true;
         }
+        if (text === "/steer" || text.startsWith("/steer ") || text.startsWith("/steer@")) {
+            const adapter = this.getReplyAdapter(msg);
+            if (!adapter)
+                return false;
+            // Deliberately NOT admin-gated: anyone who can speak in this topic can
+            // already send the instance a message; /steer only changes WHEN it lands
+            // (mid-turn instead of after), and it goes through the full [user:]
+            // formatting — unlike /raw, which bypasses it and is gated.
+            const content = text.replace(/^\/steer(@\S+)?/, "").trim();
+            if (!content) {
+                await adapter.sendText(msg.chatId, t("steer.usage"), { threadId: msg.threadId });
+                return true;
+            }
+            const result = this.sendSteer(instanceName, content, msg);
+            await adapter.sendText(msg.chatId, result, { threadId: msg.threadId });
+            return true;
+        }
+        if (text === "/btw" || text.startsWith("/btw ") || text.startsWith("/btw@")) {
+            const adapter = this.getReplyAdapter(msg);
+            if (!adapter)
+                return false;
+            // Like /steer, /btw is not admin-gated: anyone who can send the agent a
+            // normal message may ask a side question. Claude owns the isolation from
+            // the active turn; AgEnD only submits its native command immediately.
+            const content = text.replace(/^\/btw(@\S+)?/, "").trim();
+            if (!content) {
+                await adapter.sendText(msg.chatId, t("btw.usage"), { threadId: msg.threadId });
+                return true;
+            }
+            const result = this.sendBtw(instanceName, content, msg);
+            await adapter.sendText(msg.chatId, result, { threadId: msg.threadId });
+            return true;
+        }
         if (text === "/clear" || text.startsWith("/clear@")) {
             const adapter = this.getReplyAdapter(msg);
             if (!adapter)
@@ -475,7 +557,7 @@ export class TopicCommands {
     }
     async runPauseWake(instanceName, action) {
         if (action === "pause" && isGeneralInstance(this.ctx.fleetConfig, instanceName)) {
-            return GENERAL_PAUSE_ERROR;
+            return t("general.pause_forbidden");
         }
         try {
             const result = await this.ctx.changeInstancePauseState(instanceName, action);
@@ -506,7 +588,10 @@ export class TopicCommands {
         const contextLine = context == null ? null : formatContextUsageLine(context, tokenRatio);
         // Effective model (resolves per-instance → fleet default → classic channel →
         // the CLI's own default) via the shared resolver, so /ctx and /model agree.
-        const modelDisplay = this.ctx.modelDisplayForInstance?.(instanceName);
+        const modelDisplay = backend === "claude-code"
+            ? readStatuslineModel(this.ctx.dataDir, instanceName)
+                ?? this.ctx.modelDisplayForInstance?.(instanceName)
+            : this.ctx.modelDisplayForInstance?.(instanceName);
         const modelLine = modelDisplay ? `\n${t("ctx.model", modelDisplay)}` : "";
         return context != null
             ? `${contextLine}\n${t("ctx.backend", backend)}${modelLine}\n${t("ctx.instance", instanceName)}`
@@ -524,23 +609,88 @@ export class TopicCommands {
                 ?? this.ctx.fleetConfig?.defaults?.backend ?? "claude-code";
             const cmd = compactCommandForBackend(backend);
             ipc.send({ type: "raw_paste", content: cmd });
-            return `🗜️ Compact command sent (\`${cmd}\`).`;
+            return t("compact.sent", cmd);
         }
-        return "❌ Instance not connected (IPC unavailable)";
+        return t("compact.not_connected");
     }
     /** Whether the instance backend exposes a verified full-reset command. */
     supportsClear(instanceName) {
         return clearCommandForBackend(this.effectiveBackend(instanceName)) !== null;
     }
+    /**
+     * Steer: interject a message into the instance's CURRENT turn. The daemon
+     * pastes it into the busy CLI instead of queueing for idle (falling back to
+     * the queue if the TUI swallows busy input — see Daemon.steerMessage).
+     */
+    /**
+     * Backends whose TUI accepts a busy-pane paste as steering input,
+     * live-verified: claude-code and codex buffer-then-submit at the turn
+     * boundary, grok accepts it in its input line. kiro's legacy TUI swallows
+     * the paste outright, and opencode/antigravity are unverified — for those
+     * the user gets an honest "not supported" instead of a silent queue
+     * fallback that looks like a steer but behaves like a normal message.
+     */
+    sendSteer(instanceName, content, msg) {
+        const backend = this.effectiveBackend(instanceName);
+        if (!backendSupportsSteer(backend)) {
+            return t("steer.unsupported", backend);
+        }
+        const ipc = this.ctx.instanceIpcClients.get(instanceName);
+        if (!ipc?.connected)
+            return t("steer.not_connected");
+        ipc.send({
+            type: "steer",
+            content,
+            delivery_epoch: this.ctx.getDeliveryEpoch?.(instanceName) ?? undefined,
+            meta: {
+                chat_id: msg.chatId,
+                message_id: msg.messageId ?? "",
+                user: msg.username,
+                user_id: msg.userId,
+                thread_id: msg.threadId ?? "",
+                adapter_id: msg.adapterId ?? "",
+                source: msg.source,
+            },
+        });
+        return t("steer.sent", instanceName);
+    }
+    /** Ask a Claude Code side question without folding it into the active turn. */
+    sendBtw(instanceName, content, msg) {
+        const backend = this.effectiveBackend(instanceName);
+        if (!BTW_SUPPORTED_BACKENDS.has(backend))
+            return t("btw.unsupported", backend);
+        const ipc = this.ctx.instanceIpcClients.get(instanceName);
+        if (!ipc?.connected)
+            return t("btw.not_connected");
+        ipc.send({
+            type: "btw",
+            content,
+            delivery_epoch: this.ctx.getDeliveryEpoch?.(instanceName) ?? undefined,
+            meta: {
+                chat_id: msg.chatId,
+                message_id: msg.messageId ?? "",
+                user: msg.username,
+                user_id: msg.userId,
+                thread_id: msg.threadId ?? "",
+                adapter_id: msg.adapterId ?? "",
+                source: msg.source,
+            },
+        });
+        return t("btw.sent", instanceName);
+    }
     /** Send the backend-appropriate full conversation reset through raw_paste. */
     async sendClear(instanceName) {
         const backend = this.effectiveBackend(instanceName);
         const cmd = clearCommandForBackend(backend);
         if (!cmd)
-            return CLEAR_UNSUPPORTED_MSG;
+            return t("clear.unsupported");
         const ipc = this.ctx.instanceIpcClients.get(instanceName);
         if (ipc?.connected) {
-            ipc.send({ type: "raw_paste", content: cmd });
+            ipc.send({
+                type: "raw_paste",
+                content: cmd,
+                ...(backend === "kiro-cli" ? { confirm_clear: true } : {}),
+            });
             return t("clear.sent", cmd);
         }
         return t("clear.not_connected");
@@ -555,13 +705,13 @@ export class TopicCommands {
             ?? this.ctx.fleetConfig?.defaults?.backend ?? "claude-code";
         const cmd = saveCommandForBackend(backend, filename);
         if (!cmd)
-            return SAVE_UNSUPPORTED_MSG;
+            return t("save.unsupported");
         const ipc = this.ctx.instanceIpcClients.get(instanceName);
         if (ipc?.connected) {
             ipc.send({ type: "raw_paste", content: cmd });
-            return `💾 Save command sent (\`${cmd}\`).`;
+            return t("save.sent", cmd, instanceName);
         }
-        return "❌ Instance not connected (IPC unavailable)";
+        return t("save.not_connected");
     }
     async handleRestartCommand(msg) {
         const adapter = this.getReplyAdapter(msg);
@@ -578,8 +728,8 @@ export class TopicCommands {
         process.kill(process.pid, "SIGUSR2");
     }
     /**
-     * `/usage` — AI subscription usage for every CLI backend logged in on this
-     * machine, one compact message. Same permission level as /ctx (none): whoever
+     * `/usage` — AI subscription usage for CLI backends used by running or paused
+     * instances, one compact message. Same permission level as /ctx (none): whoever
      * can talk to the fleet may see how much headroom it has left. Vendor rate
      * limits are protected by the shared 5-minute cache, not by gating callers.
      */
@@ -590,7 +740,7 @@ export class TopicCommands {
         try {
             const { getUsageSnapshot } = await import("./usage/usage-api.js");
             const { renderUsageHtml, renderUsageMarkdown } = await import("./usage/format-rich.js");
-            const payload = await getUsageSnapshot();
+            const payload = await getUsageSnapshot(false, this.ctx.getActiveUsageProviderIds?.());
             // Each platform gets its native rich format: Telegram needs parse_mode
             // HTML; Discord renders Markdown in plain content. Anything else falls back
             // to Markdown, which degrades to readable text.
@@ -602,7 +752,140 @@ export class TopicCommands {
             }
         }
         catch (err) {
-            await adapter.sendText(msg.chatId, `⚠️ Usage fetch failed: ${err.message}`, { threadId: msg.threadId });
+            await adapter.sendText(msg.chatId, t("usage.failed", err.message), { threadId: msg.threadId });
+        }
+    }
+    /**
+     * `/login [backend] | code <text> | cancel` — remote CLI re-login.
+     * Fleet-admin only: the flow emits live authorization URLs/codes, and anyone
+     * completing one binds their own account to this fleet's CLI.
+     */
+    async handleLoginCommand(msg) {
+        const adapter = this.getReplyAdapter(msg);
+        if (!adapter)
+            return;
+        if (!this.ctx.isFleetAdmin(msg.userId, msg.adapterId)) {
+            await adapter.sendText(msg.chatId, t("permission.denied"), { threadId: msg.threadId });
+            return;
+        }
+        if (!this.ctx.startLoginSession || !this.ctx.promptLoginBackends
+            || !this.ctx.loginSubmitInput || !this.ctx.cancelLoginSession) {
+            await adapter.sendText(msg.chatId, t("login.no_session"), { threadId: msg.threadId });
+            return;
+        }
+        const arg = msg.text.trim().replace(/^\/login(?:@\S+)?/, "").trim();
+        const chat = {
+            adapter,
+            adapterId: msg.adapterId ?? adapter.id,
+            chatId: msg.chatId,
+            threadId: msg.threadId,
+        };
+        if (!arg) {
+            await this.ctx.promptLoginBackends(chat);
+            return;
+        }
+        if (arg === "cancel") {
+            await adapter.sendText(msg.chatId, await this.ctx.cancelLoginSession(), { threadId: msg.threadId });
+            return;
+        }
+        if (arg.startsWith("code ")) {
+            const input = arg.slice(5).trim();
+            const reply = input ? await this.ctx.loginSubmitInput(input) : t("login.usage");
+            await adapter.sendText(msg.chatId, reply, { threadId: msg.threadId });
+            return;
+        }
+        if (/\s/.test(arg)) {
+            await adapter.sendText(msg.chatId, t("login.usage"), { threadId: msg.threadId });
+            return;
+        }
+        const started = await this.ctx.startLoginSession(arg, chat);
+        // null → the still-valid-auth confirmation prompt was posted instead.
+        if (started)
+            await adapter.sendText(msg.chatId, started, { threadId: msg.threadId });
+    }
+    /** `/install-cli <backend> | cancel` — remote CLI install. Fleet-admin only. */
+    async handleInstallCliCommand(msg) {
+        const adapter = this.getReplyAdapter(msg);
+        if (!adapter)
+            return;
+        if (!this.ctx.isFleetAdmin(msg.userId, msg.adapterId)) {
+            await adapter.sendText(msg.chatId, t("permission.denied"), { threadId: msg.threadId });
+            return;
+        }
+        if (!this.ctx.startInstallSession || !this.ctx.cancelInstallSession) {
+            await adapter.sendText(msg.chatId, t("install.no_session"), { threadId: msg.threadId });
+            return;
+        }
+        const arg = msg.text.trim().replace(/^\/install[-_]cli(?:@\S+)?/, "").trim();
+        // Bare call → offer the backends, matching bare `/login`. A multi-word arg
+        // is still a usage error: it means they typed something, just not a backend.
+        if (!arg && this.ctx.promptInstallBackends) {
+            await this.ctx.promptInstallBackends({
+                adapter,
+                adapterId: msg.adapterId ?? adapter.id,
+                chatId: msg.chatId,
+                threadId: msg.threadId,
+            });
+            return;
+        }
+        if (!arg || /\s/.test(arg)) {
+            await adapter.sendText(msg.chatId, t("install.usage"), { threadId: msg.threadId });
+            return;
+        }
+        if (arg === "cancel") {
+            await adapter.sendText(msg.chatId, await this.ctx.cancelInstallSession(), { threadId: msg.threadId });
+            return;
+        }
+        const chat = {
+            adapter,
+            adapterId: msg.adapterId ?? adapter.id,
+            chatId: msg.chatId,
+            threadId: msg.threadId,
+        };
+        await adapter.sendText(msg.chatId, await this.ctx.startInstallSession(arg, chat), { threadId: msg.threadId });
+    }
+    async handleTipsCommand(msg) {
+        const adapter = this.getReplyAdapter(msg);
+        if (!adapter || !this.ctx.fleetConfig)
+            return;
+        const mode = msg.text.trim().replace(/^\/tips(?:@\S+)?/, "").trim().toLowerCase();
+        if (mode === "advanced on") {
+            if (!this.ctx.isFleetAdmin(msg.userId, msg.adapterId)) {
+                await adapter.sendText(msg.chatId, t("permission.denied"), { threadId: msg.threadId });
+                return;
+            }
+            await adapter.sendText(msg.chatId, this.ctx.unlockAdvancedTips?.(msg.userId)
+                ? t("tips.advanced.unlocked")
+                : t("tips.unavailable"), { threadId: msg.threadId });
+            return;
+        }
+        if (mode === "on" || mode === "off") {
+            if (!this.ctx.isFleetAdmin(msg.userId, msg.adapterId)) {
+                await adapter.sendText(msg.chatId, t("permission.denied"), { threadId: msg.threadId });
+                return;
+            }
+            this.ctx.fleetConfig.defaults.tips = mode === "on";
+            this.ctx.saveFleetConfig();
+            await adapter.sendText(msg.chatId, t(mode === "on" ? "tips.enabled" : "tips.disabled"), {
+                threadId: msg.threadId,
+            });
+            return;
+        }
+        if (mode) {
+            await adapter.sendText(msg.chatId, t("tips.usage"), { threadId: msg.threadId });
+            return;
+        }
+        const result = await this.ctx.promptTip?.(
+        // The instance name scopes prompt cleanup; the Tip is posted at the
+        // caller's current chat/thread below.
+        Object.entries(this.ctx.fleetConfig.instances)
+            .find(([, config]) => config.general_topic === true
+            && (!config.channel_id || config.channel_id === msg.adapterId))?.[0] ?? "general", adapter, msg.chatId, msg.threadId) ?? "unavailable";
+        if (result === "empty") {
+            await adapter.sendText(msg.chatId, t("tips.empty"), { threadId: msg.threadId });
+        }
+        else if (result === "unavailable") {
+            await adapter.sendText(msg.chatId, t("tips.unavailable"), { threadId: msg.threadId });
         }
     }
     async handleStatusCommand(msg) {
@@ -631,7 +914,7 @@ export class TopicCommands {
     /** Get fleet status as markdown text (shared by TG + DC) */
     async getStatusText() {
         if (!this.ctx.fleetConfig)
-            return "No fleet config loaded.";
+            return t("status.no_config");
         const rows = [];
         let pausedCount = 0;
         const fleetNames = new Set(Object.keys(this.ctx.fleetConfig.instances));
@@ -668,10 +951,10 @@ export class TopicCommands {
                 icon = "🔴";
             else
                 icon = "⚪";
-            const stateLabel = executionState === "idle" ? "🟢 idle"
-                : executionState === "working" ? "🔵 working"
-                    : executionState === "stuck" ? "🔴 stuck"
-                        : executionState === "paused" ? "⏸ paused"
+            const stateLabel = executionState === "idle" ? `🟢 ${t("state.idle")}`
+                : executionState === "working" ? `🔵 ${t("state.working")}`
+                    : executionState === "stuck" ? `🔴 ${t("state.stuck")}`
+                        : executionState === "paused" ? `⏸ ${t("state.paused")}`
                             : "—";
             const displayName = this.shortInstanceName(name);
             // IPC reachability moved here from /sysinfo: it is per-instance health, and
@@ -683,27 +966,27 @@ export class TopicCommands {
             rows.push(`| ${displayName} | ${backend} | ${contextStr} | ${effort} | ${formatCents(costCents)} | ${icon} | ${stateLabel} | ${ipc} |`);
         }
         if (rows.length === 0)
-            return "No instances configured.";
+            return t("status.no_instances");
         const lines = [
-            "## Fleet Status",
+            `## ${t("status.title")}`,
             "",
-            "| Instance | Backend | Ctx | Effort | Cost | Status | State | IPC |",
+            t("status.table_header"),
             "|----------|---------|-----|--------|------|--------|-------|-----|",
             ...rows,
             "",
-            `Paused instances: ${pausedCount}`,
+            t("status.paused_count", pausedCount),
         ];
         const limitCents = this.ctx.costGuard?.getLimitCents() ?? 0;
         const totalCents = this.ctx.costGuard?.getFleetTotalCents() ?? 0;
         if (limitCents > 0) {
-            lines.push("", `Fleet: ${formatCents(totalCents)} / ${formatCents(limitCents)} daily`);
+            lines.push("", t("status.daily_cost", formatCents(totalCents), formatCents(limitCents)));
         }
         // Adapter states (only show if any are not connected)
         const adapterStates = this.ctx.getAdapterStates?.();
         if (adapterStates && adapterStates.size > 0) {
             const issues = [...adapterStates.entries()].filter(([, s]) => s.status !== "connected");
             if (issues.length > 0) {
-                lines.push("", "**Adapters:**");
+                lines.push("", `**${t("status.adapters")}**`);
                 for (const [id, s] of adapterStates) {
                     const icon = s.status === "connected" ? "✅" : s.status === "retrying" ? "🔄" : "❌";
                     lines.push(`  ${icon} ${id}: ${s.status}${s.lastError ? ` (${s.lastError.slice(0, 60)})` : ""}`);
@@ -716,35 +999,73 @@ export class TopicCommands {
         const adapter = this.getReplyAdapter(msg);
         if (!adapter)
             return;
-        const text = this.getSysInfoText();
+        const platform = adapter.type === "discord" ? "discord" : "telegram";
+        const text = this.getSysInfoText({ platform });
         await adapter.sendText(msg.chatId, text, { threadId: msg.threadId });
     }
     /**
-     * Get system info as markdown text (shared by TG + DC).
+     * Get system info as formatted text.
      *
      * System-level only. The per-instance table (state/IPC/cost) moved to /status,
      * which was already the fleet-per-instance view — the two tables overlapped on
      * everything but the IPC column, and each command answered half of "is the
      * machine fine and are the instances fine".
+     *
+     * @param opts.platform - "telegram" uses markdown table, "discord" uses plain lines
      */
-    getSysInfoText() {
+    getSysInfoText(opts) {
         const info = this.ctx.getSysInfo();
         const upHours = Math.floor(info.uptime_seconds / 3600);
         const upMins = Math.floor((info.uptime_seconds % 3600) / 60);
         const require = createRequire(import.meta.url);
         const agendVersion = require("../package.json").version ?? "unknown";
+        const tipsLang = getLocale() === "zh-TW" ? "zh" : "en";
+        // Fleet summary lines (multi-line for mobile readability)
+        const summaryLines = [
+            `${t("sysinfo.instances")}: ${info.running_count} ${t("sysinfo.running")}, ${info.paused_count} ${t("sysinfo.paused")}`,
+            ...(info.fleet_mem_mb !== null ? [`${t("sysinfo.fleet_mem")}: ${(info.fleet_mem_mb / 1024).toFixed(1)} GB`] : []),
+            `${t("sysinfo.system_mem")}: ${info.system_mem_gb.used} / ${info.system_mem_gb.total} GB`,
+        ];
+        const resources = [
+            `📚 **${t("sysinfo.resources")}**`,
+            `- ${t("sysinfo.docs")}: https://songsid.github.io/AgEnD`,
+            `- ${t("sysinfo.tips")}: https://songsid.github.io/AgEnD/tips-${tipsLang}.html`,
+            `- ${t("sysinfo.github")}: https://github.com/songsid/AgEnD`,
+        ];
+        // Discord: plain key-value lines (Discord doesn't render markdown tables)
+        if (opts?.platform === "discord") {
+            return [
+                `## ${t("sysinfo.title")}`,
+                `AgEnD: v${agendVersion}`,
+                `OS: ${process.platform} ${osRelease()} (${process.arch})`,
+                `Node: ${process.version}`,
+                `tmux: ${tmuxVersion()}`,
+                `${t("sysinfo.uptime")}: ${upHours}h ${upMins}m`,
+                `${t("sysinfo.memory")}: ${info.memory_mb.rss} MB RSS`,
+                `${t("sysinfo.heap")}: ${info.memory_mb.heapUsed} / ${info.memory_mb.heapTotal} MB`,
+                "",
+                ...summaryLines,
+                "",
+                ...resources,
+            ].join("\n");
+        }
+        // Telegram (default): markdown table
         return [
-            "## System Info",
+            `## ${t("sysinfo.title")}`,
             "",
-            "| Metric | Value |",
+            `| ${t("sysinfo.metric")} | ${t("sysinfo.value")} |`,
             "|--------|-------|",
             `| AgEnD | v${agendVersion} |`,
             `| OS | ${process.platform} ${osRelease()} (${process.arch}) |`,
             `| Node | ${process.version} |`,
             `| tmux | ${tmuxVersion()} |`,
-            `| Uptime | ${upHours}h ${upMins}m |`,
-            `| Memory | ${info.memory_mb.rss} MB RSS |`,
-            `| Heap | ${info.memory_mb.heapUsed} / ${info.memory_mb.heapTotal} MB |`,
+            `| ${t("sysinfo.uptime")} | ${upHours}h ${upMins}m |`,
+            `| ${t("sysinfo.memory")} | ${info.memory_mb.rss} MB RSS |`,
+            `| ${t("sysinfo.heap")} | ${info.memory_mb.heapUsed} / ${info.memory_mb.heapTotal} MB |`,
+            "",
+            ...summaryLines,
+            "",
+            ...resources,
         ].join("\n");
     }
     async handleUpdateCommand(msg) {
@@ -797,11 +1118,11 @@ export class TopicCommands {
                 timeout: 30_000,
                 encoding: "utf-8",
             });
-            output = stripAnsi(stdout) || "No output";
+            output = stripAnsi(stdout) || t("doctor.no_output");
         }
         catch (err) {
             const e = err;
-            output = stripAnsi(e.stdout ?? e.message ?? "Doctor failed");
+            output = stripAnsi(e.stdout ?? e.message ?? t("doctor.failed"));
         }
         await adapter.sendText(chatId, output, { threadId });
     }
@@ -810,7 +1131,7 @@ export class TopicCommands {
         const adapter = this.getReplyAdapter(msg);
         if (!adapter)
             return;
-        await adapter.sendText(msg.chatId, "This topic is not bound to an instance. Ask the General assistant to create one with create_instance.", { threadId: msg.threadId });
+        await adapter.sendText(msg.chatId, t("topic.unbound"), { threadId: msg.threadId });
     }
     /** Handle topic deletion — stop daemon and remove from config */
     async handleTopicDeleted(threadId) {
@@ -923,21 +1244,26 @@ export class TopicCommands {
             }
             try {
                 const fleetCommands = [
-                    { command: "status", description: "🔒 Fleet status, per-instance costs and health" },
-                    { command: "sysinfo", description: "System diagnostics" },
-                    { command: "dashboard", description: "🔒 Get dashboard URLs" },
-                    { command: "ctx", description: "Show context usage" },
-                    { command: "compact", description: "Compact agent context" },
-                    { command: "clear", description: "🔒 Clear agent conversation context" },
-                    { command: "model", description: "🔒 Switch model (admin only)" },
-                    { command: "effort", description: "🔒 Set reasoning effort (admin only)" },
-                    { command: "pause", description: "🔒 Pause an idle instance" },
-                    { command: "wake", description: "🔒 Wake a paused instance" },
-                    { command: "restart", description: "🔒 Graceful restart all instances" },
-                    { command: "collab", description: "🔒 Toggle bot/webhook mode" },
-                    { command: "update", description: "🔒 Update AgEnD to latest" },
-                    { command: "doctor", description: "🔒 Run health diagnostics" },
-                    { command: "usage", description: "AI subscription usage" },
+                    { command: "status", description: "🔒 " + t("slash.status") },
+                    { command: "sysinfo", description: t("slash.sysinfo") },
+                    { command: "dashboard", description: "🔒 " + t("slash.dashboard") },
+                    { command: "ctx", description: t("slash.ctx") },
+                    { command: "compact", description: t("slash.compact") },
+                    { command: "steer", description: t("slash.steer") },
+                    { command: "btw", description: t("slash.btw") },
+                    { command: "clear", description: "🔒 " + t("slash.clear") },
+                    { command: "model", description: "🔒 " + t("slash.model") },
+                    { command: "effort", description: "🔒 " + t("slash.effort") },
+                    { command: "pause", description: "🔒 " + t("slash.pause") },
+                    { command: "wake", description: "🔒 " + t("slash.wake") },
+                    { command: "restart", description: "🔒 " + t("slash.restart") },
+                    { command: "collab", description: "🔒 " + t("slash.collab") },
+                    { command: "update", description: "🔒 " + t("slash.update") },
+                    { command: "doctor", description: "🔒 " + t("slash.doctor") },
+                    { command: "login", description: "🔒 " + t("slash.login") },
+                    { command: "install_cli", description: "🔒 " + t("slash.install_cli") },
+                    { command: "usage", description: t("slash.usage") },
+                    { command: "tips", description: t("slash.tips") },
                 ];
                 const setCommands = async (commands, scope) => {
                     const response = await fetch(`https://api.telegram.org/bot${botToken}/setMyCommands`, {
@@ -958,15 +1284,17 @@ export class TopicCommands {
                     }
                 };
                 const classicCommands = [
-                    { command: "start", description: "🔒 Start an agent in this chat" },
-                    { command: "stop", description: "🔒 Stop the agent" },
-                    { command: "compact", description: "🔒 Compact agent context" },
-                    { command: "clear", description: "🔒 Clear agent conversation context" },
-                    { command: "model", description: "🔒 Switch model (admin only)" },
-                    { command: "effort", description: "🔒 Set reasoning effort (admin only)" },
-                    { command: "pause", description: "🔒 Pause the agent" },
-                    { command: "wake", description: "🔒 Wake the agent" },
-                    { command: "ctx", description: "Show context usage" },
+                    { command: "start", description: "🔒 " + t("slash.start") },
+                    { command: "stop", description: "🔒 " + t("slash.stop") },
+                    { command: "compact", description: "🔒 " + t("slash.compact") },
+                    { command: "steer", description: t("slash.steer") },
+                    { command: "btw", description: t("slash.btw") },
+                    { command: "clear", description: "🔒 " + t("slash.clear") },
+                    { command: "model", description: "🔒 " + t("slash.model") },
+                    { command: "effort", description: "🔒 " + t("slash.effort") },
+                    { command: "pause", description: "🔒 " + t("slash.pause") },
+                    { command: "wake", description: "🔒 " + t("slash.wake") },
+                    { command: "ctx", description: t("slash.ctx") },
                 ];
                 // A chat_administrators scope has higher precedence than the chat scope.
                 // Keep both synchronized so a stale admin-only list from BotFather or an