@songsid/agend 2.1.2-beta.9 → 2.1.2

package/dist/topic-commands.js

@@ -1,14 +1,16 @@
 import { readFileSync, existsSync } from "node:fs";
-import { exec } from "node:child_process";
+import { exec, execFileSync } from "node:child_process";
 import { promisify } from "node:util";
 import { join, basename } from "node:path";
+import { release } from "node:os";
 import { createRequire } from "node:module";
 const execAsync = promisify(exec);
 import { DEFAULT_INSTANCE_CONFIG } from "./config.js";
 import { formatCents } from "./cost-guard.js";
-import { getAgendHome } from "./paths.js";
+import { getTmuxSocketName, getTmuxSessionName } from "./paths.js";
 import { t } from "./locale.js";
 import { PIE_PERCENT_RE } from "./tui-glyphs.js";
+import { GENERAL_PAUSE_ERROR, isGeneralInstance } from "./general-instance.js";
 /** Sanitize a directory name into a valid instance name. Keeps Unicode letters (incl. CJK). */
 export function sanitizeInstanceName(name) {
     const sanitized = name.toLowerCase().replace(/[^\p{L}\d-]/gu, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
@@ -48,6 +50,32 @@ export function parsePauseWakeCommand(text) {
  * Antigravity (agy) has NO summarizing compact — its only manual context-reset
  * is "/clear" (a full reset; it also auto-summarizes at a token threshold).
  */
+/** os.release(), guarded — purely informational, must never break /sysinfo. */
+function osRelease() {
+    try {
+        return release();
+    }
+    catch {
+        return "?";
+    }
+}
+/**
+ * `tmux -V`, memoised. One short synchronous exec for the lifetime of the
+ * process — /sysinfo is on-demand and rare, and the version cannot change under
+ * a running fleet (the server would have to restart with it).
+ */
+let cachedTmuxVersion = null;
+function tmuxVersion() {
+    if (cachedTmuxVersion === null) {
+        try {
+            cachedTmuxVersion = execFileSync("tmux", ["-V"], { encoding: "utf-8", timeout: 3000 }).trim();
+        }
+        catch {
+            cachedTmuxVersion = "not found";
+        }
+    }
+    return cachedTmuxVersion;
+}
 export function compactCommandForBackend(backend) {
     if (backend === "antigravity")
         return "/clear";
@@ -101,6 +129,115 @@ export function parseContextPercent(pane) {
     }
     return null;
 }
+/** Claude Code statusline.json context used % (null if missing / unreadable). */
+export function readStatuslineContextPct(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 pct = data.context_window?.used_percentage;
+        return typeof pct === "number" && Number.isFinite(pct) ? pct : null;
+    }
+    catch {
+        return null;
+    }
+}
+/** Live-pane scrape used by /ctx, /status Ctx, and /view sidebar. */
+export function scrapePaneContext(instanceName, backend) {
+    try {
+        const socketName = getTmuxSocketName();
+        // Scrollback (-S -60) so a recent footer/statusline is kept even mid-output.
+        const baseArgs = ["capture-pane", "-t", `${getTmuxSessionName()}:${instanceName}`, "-p", "-S", "-60"];
+        const tmuxArgs = socketName ? ["-L", socketName, ...baseArgs] : baseArgs;
+        const pane = execFileSync("tmux", tmuxArgs, {
+            encoding: "utf-8",
+            timeout: 2000,
+            stdio: ["pipe", "pipe", "pipe"],
+        });
+        const tokenRatio = backend === "grok" ? parseTokenContextRatio(pane) : null;
+        const context = tokenRatio?.percentage ?? parseContextPercent(pane);
+        return { context, tokenRatio };
+    }
+    catch {
+        return { context: null, tokenRatio: null };
+    }
+}
+const paneContextCache = new Map();
+// Below the dashboard's 10s SSE tick on purpose: at the previous 12s the cache was
+// guaranteed to be stale on roughly every other tick, which is what made the
+// blocking scrape fire so often. Now a tick either hits the cache or triggers a
+// background refresh, never a synchronous capture.
+const PANE_CONTEXT_CACHE_MS = 8_000;
+/** Instances with a background scrape in flight, so polls don't pile up captures. */
+const paneScrapeInFlight = new Set();
+/** Async twin of scrapePaneContext — same parsers, no blocking. */
+async function scrapePaneContextAsync(instanceName, backend) {
+    try {
+        const socketName = getTmuxSocketName();
+        const baseArgs = ["capture-pane", "-t", `${getTmuxSessionName()}:${instanceName}`, "-p", "-S", "-60"];
+        const tmuxArgs = socketName ? ["-L", socketName, ...baseArgs] : baseArgs;
+        const { promisify } = await import("node:util");
+        const { execFile } = await import("node:child_process");
+        const { stdout } = await promisify(execFile)("tmux", tmuxArgs, { encoding: "utf-8", timeout: 2000 });
+        const pane = stdout.toString();
+        const tokenRatio = backend === "grok" ? parseTokenContextRatio(pane) : null;
+        return { context: tokenRatio?.percentage ?? parseContextPercent(pane), tokenRatio };
+    }
+    catch {
+        return { context: null, tokenRatio: null };
+    }
+}
+/** Refresh one instance's cached context in the background (deduped per instance). */
+function refreshPaneContext(instanceName, backend) {
+    if (paneScrapeInFlight.has(instanceName))
+        return;
+    paneScrapeInFlight.add(instanceName);
+    void scrapePaneContextAsync(instanceName, backend)
+        .then(scraped => { paneContextCache.set(instanceName, { at: Date.now(), ...scraped }); })
+        .finally(() => { paneScrapeInFlight.delete(instanceName); });
+}
+/** Forget a deleted instance's cached context so the map can't grow forever. */
+export function forgetInstanceContext(instanceName) {
+    paneContextCache.delete(instanceName);
+}
+/**
+ * Single source of truth for instance context % across /ctx, /status, and View.
+ * Claude-code prefers statusline.json (authoritative, no TUI scrape); everyone
+ * else scrapes the live pane with the same parsers /ctx uses.
+ *
+ * Non-blocking by default (stale-while-revalidate): a fresh cache entry is
+ * returned as-is; a stale or missing one is returned immediately anyway while a
+ * background refresh runs. This used to scrape synchronously with `execFileSync`
+ * (2s timeout) on a cache miss, and the 12s TTL is LONGER than the dashboard's
+ * 10s poll — so roughly every other tick did N blocking captures. With ten
+ * non-claude-code instances and a slow tmux that froze the entire fleet event
+ * loop for up to 20s per tick: no IPC, no message delivery, no watchdog ping.
+ * Three open browser tabs ran three independent polls.
+ *
+ * Pass `bypassCache` for a synchronous, authoritative read — used by `/ctx`,
+ * where a user is asking right now and 2s of blocking is the correct trade.
+ */
+export function resolveInstanceContext(dataDir, instanceName, backend, opts) {
+    if (backend === "claude-code") {
+        const fromFile = readStatuslineContextPct(dataDir, instanceName);
+        if (fromFile != null)
+            return { context: fromFile, tokenRatio: null };
+    }
+    if (opts?.bypassCache) {
+        const scraped = scrapePaneContext(instanceName, backend);
+        paneContextCache.set(instanceName, { at: Date.now(), ...scraped });
+        return scraped;
+    }
+    const hit = paneContextCache.get(instanceName);
+    if (hit && Date.now() - hit.at < PANE_CONTEXT_CACHE_MS) {
+        return { context: hit.context, tokenRatio: hit.tokenRatio };
+    }
+    // Stale or absent: kick off the refresh and answer with what we have. A brand-new
+    // instance reads as "no data" for one tick rather than blocking the fleet.
+    refreshPaneContext(instanceName, backend);
+    return hit ? { context: hit.context, tokenRatio: hit.tokenRatio } : { context: null, tokenRatio: null };
+}
 export class TopicCommands {
     ctx;
     constructor(ctx) {
@@ -135,6 +272,10 @@ export class TopicCommands {
             await this.handleDoctorCommand(msg);
             return true;
         }
+        if (text === "/usage" || text.startsWith("/usage@")) {
+            await this.handleUsageCommand(msg);
+            return true;
+        }
         if (text === "/update" || text.startsWith("/update@")) {
             await this.handleUpdateCommand(msg);
             return true;
@@ -155,11 +296,10 @@ export class TopicCommands {
     getDashboardText(htmlSpoiler = false) {
         const port = this.ctx.fleetConfig?.health_port ?? 19280;
         const host = this.ctx.fleetConfig?.hostname || "localhost";
-        let token = "";
-        try {
-            token = readFileSync(join(getAgendHome(), "web.token"), "utf-8").trim();
-        }
-        catch { /* not started yet */ }
+        const access = this.ctx.getDashboardAccess?.();
+        if (!access?.ready || !access.token)
+            return t("dashboard.starting");
+        const token = access.token;
         const base = `http://${host}:${port}`;
         const hide = (u) => htmlSpoiler ? `<tg-spoiler>${u}</tg-spoiler>` : u;
         return [
@@ -217,6 +357,10 @@ export class TopicCommands {
                 await adapter.sendText(msg.chatId, t("instance.not_found", target), { threadId: msg.threadId });
                 return true;
             }
+            if (pauseWake.action === "pause" && isGeneralInstance(this.ctx.fleetConfig, target)) {
+                await adapter.sendText(msg.chatId, GENERAL_PAUSE_ERROR, { threadId: msg.threadId });
+                return true;
+            }
             await adapter.sendText(msg.chatId, await this.runPauseWake(target, pauseWake.action), { threadId: msg.threadId });
             return true;
         }
@@ -230,6 +374,28 @@ export class TopicCommands {
                 : t("collab.off"), { threadId: msg.threadId });
             return true;
         }
+        if (text === "/effort" || text.startsWith("/effort ") || text.startsWith("/effort@")) {
+            const adapter = this.getReplyAdapter(msg);
+            if (!adapter)
+                return false;
+            if (!this.ctx.isFleetAdmin(msg.userId, msg.adapterId)) {
+                await adapter.sendText(msg.chatId, t("permission.denied"), { threadId: msg.threadId });
+                return true;
+            }
+            const level = text.replace(/^\/effort(@\S+)?/, "").trim();
+            if (level) {
+                const reply = await this.ctx.applyEffort?.(instanceName, level)
+                    ?? "Effort switching is unavailable.";
+                await adapter.sendText(msg.chatId, reply, { threadId: msg.threadId });
+            }
+            else if (this.ctx.promptEffortMenu) {
+                // No arg → inline keyboard menu (TG), same shape as /model.
+                const fallback = await this.ctx.promptEffortMenu(instanceName, msg.userId, msg.threadId ?? msg.chatId, adapter, msg.chatId, msg.threadId);
+                if (fallback)
+                    await adapter.sendText(msg.chatId, fallback, { threadId: msg.threadId });
+            }
+            return true;
+        }
         if (text === "/model" || text.startsWith("/model ") || text.startsWith("/model@")) {
             const adapter = this.getReplyAdapter(msg);
             if (!adapter)
@@ -297,6 +463,9 @@ export class TopicCommands {
         return true;
     }
     async runPauseWake(instanceName, action) {
+        if (action === "pause" && isGeneralInstance(this.ctx.fleetConfig, instanceName)) {
+            return GENERAL_PAUSE_ERROR;
+        }
         try {
             const result = await this.ctx.changeInstancePauseState(instanceName, action);
             if (result === "not_idle")
@@ -307,50 +476,22 @@ export class TopicCommands {
             return t(`${action}.failed`, instanceName, err.message);
         }
     }
-    /** Get context usage text for an instance (shared by TG + DC) */
-    async getCtxText(instanceName) {
-        // Classic instances live in classicBot.yaml, not fleet.yaml → consult the
-        // classic channel manager for those so we don't mis-report defaults.backend.
-        // getBackendByInstance always returns a string (its own fallback), so only
-        // use it when the instance is ACTUALLY classic — otherwise a fleet instance
-        // that inherits its backend would wrongly pick up the classic default.
+    /** Resolve the effective backend name for fleet or classic instances. */
+    effectiveBackend(instanceName) {
         const classicBackend = this.ctx.classicChannels?.getChannelIdByInstance(instanceName)
             ? this.ctx.classicChannels.getBackendByInstance(instanceName, this.ctx.fleetConfig?.defaults?.backend)
             : undefined;
-        const backend = this.ctx.fleetConfig?.instances[instanceName]?.backend
+        return this.ctx.fleetConfig?.instances[instanceName]?.backend
             ?? classicBackend
             ?? this.ctx.fleetConfig?.defaults?.backend ?? "claude-code";
-        let context = null;
-        let tokenRatio = null;
-        // Only claude-code writes statusline.json. Reading it for other backends
-        // risks a stale value left over from a previous backend (e.g. after
-        // switching claude-code → kiro-cli), so those go straight to capture-pane.
-        if (backend === "claude-code") {
-            try {
-                const statusFile = join(this.ctx.dataDir, "instances", instanceName, "statusline.json");
-                if (existsSync(statusFile)) {
-                    const d = JSON.parse(readFileSync(statusFile, "utf-8"));
-                    context = d.context_window?.used_percentage ?? null;
-                }
-            }
-            catch { /* ignore */ }
-        }
-        if (context == null) {
-            try {
-                const { execFileSync } = await import("node:child_process");
-                const { getTmuxSocketName, getTmuxSessionName } = await import("./paths.js");
-                const socketName = getTmuxSocketName();
-                // Include scrollback (-S -60) so a recent prompt is captured even when
-                // the CLI is mid-output and the bottom of the visible pane has no prompt.
-                const baseArgs = ["capture-pane", "-t", `${getTmuxSessionName()}:${instanceName}`, "-p", "-S", "-60"];
-                const tmuxArgs = socketName ? ["-L", socketName, ...baseArgs] : baseArgs;
-                const pane = execFileSync("tmux", tmuxArgs, { encoding: "utf-8", timeout: 2000, stdio: ["pipe", "pipe", "pipe"] });
-                if (backend === "grok")
-                    tokenRatio = parseTokenContextRatio(pane);
-                context = tokenRatio?.percentage ?? parseContextPercent(pane);
-            }
-            catch { /* ignore */ }
-        }
+    }
+    /** Get context usage text for an instance (shared by TG + DC) */
+    async getCtxText(instanceName) {
+        // Classic instances live in classicBot.yaml, not fleet.yaml → consult the
+        // classic channel manager for those so we don't mis-report defaults.backend.
+        const backend = this.effectiveBackend(instanceName);
+        // Fresh scrape for /ctx (user is asking right now) — bypass short cache.
+        const { context, tokenRatio } = resolveInstanceContext(this.ctx.dataDir, instanceName, backend, { bypassCache: true });
         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.
@@ -408,10 +549,44 @@ export class TopicCommands {
         await adapter.sendText(chatId, t("restart.graceful"), { threadId });
         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
+     * 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.
+     */
+    async handleUsageCommand(msg) {
+        const adapter = this.getReplyAdapter(msg);
+        if (!adapter)
+            return;
+        try {
+            const { getUsageSnapshot } = await import("./usage/usage-api.js");
+            const { renderUsageHtml, renderUsageMarkdown } = await import("./usage/format-rich.js");
+            const payload = await getUsageSnapshot();
+            // 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.
+            if (adapter.type === "telegram") {
+                await adapter.sendText(msg.chatId, renderUsageHtml(payload), { threadId: msg.threadId, format: "html" });
+            }
+            else {
+                await adapter.sendText(msg.chatId, renderUsageMarkdown(payload), { threadId: msg.threadId });
+            }
+        }
+        catch (err) {
+            await adapter.sendText(msg.chatId, `⚠️ Usage fetch failed: ${err.message}`, { threadId: msg.threadId });
+        }
+    }
     async handleStatusCommand(msg) {
         const adapter = this.getReplyAdapter(msg);
         if (!adapter || !this.ctx.fleetConfig)
             return;
+        // Admin-gated: with the /sysinfo instance table folded in, /status now shows
+        // the whole fleet's per-instance costs and IPC health in one message.
+        if (!this.ctx.isFleetAdmin(msg.userId, msg.adapterId)) {
+            await adapter.sendText(msg.chatId, t("cmd.admin_required", "/status"), { threadId: msg.threadId });
+            return;
+        }
         const text = await this.getStatusText();
         await adapter.sendText(msg.chatId, text, { threadId: msg.threadId });
     }
@@ -446,18 +621,16 @@ export class TopicCommands {
             const costPaused = this.ctx.costGuard?.isLimited(name);
             if (status === "paused")
                 pausedCount++;
-            let contextStr = "-";
-            try {
-                const data = JSON.parse(readFileSync(join(this.ctx.dataDir, "instances", name, "statusline.json"), "utf-8"));
-                if (data.context_window?.used_percentage != null) {
-                    contextStr = `${Math.round(data.context_window.used_percentage)}%`;
-                }
-            }
-            catch { /* file may not exist yet */ }
-            const costCents = this.ctx.costGuard?.getDailyCostCents(name) ?? 0;
             const backend = classic
                 ? this.ctx.classicChannels?.getBackendByInstance(name, this.ctx.fleetConfig.defaults?.backend) ?? "-"
                 : this.ctx.fleetConfig.instances[name]?.backend ?? this.ctx.fleetConfig.defaults?.backend ?? "-";
+            // Same source as /ctx (statusline for claude-code, pane scrape otherwise).
+            // Without this, kiro/grok/codex always showed "-" in the Ctx column.
+            const { context } = backend === "-"
+                ? { context: null }
+                : resolveInstanceContext(this.ctx.dataDir, name, backend);
+            const contextStr = context == null ? "-" : `${Math.round(context)}%`;
+            const costCents = this.ctx.costGuard?.getDailyCostCents(name) ?? 0;
             let icon;
             if (costPaused || status === "paused")
                 icon = "⏸";
@@ -473,15 +646,21 @@ export class TopicCommands {
                         : executionState === "paused" ? "⏸ paused"
                             : "—";
             const displayName = this.shortInstanceName(name);
-            rows.push(`| ${displayName} | ${backend} | ${contextStr} | ${formatCents(costCents)} | ${icon} | ${stateLabel} |`);
+            // IPC reachability moved here from /sysinfo: it is per-instance health, and
+            // /status is now the one place that shows the fleet per instance.
+            const ipc = this.ctx.instanceIpcClients.has(name) ? "✓" : "✗";
+            // "-" distinguishes "backend has no effort setting" from an unset one:
+            // an empty cell would read as missing data rather than not-applicable.
+            const effort = this.ctx.resolveInstanceEffort?.(name).effort ?? "-";
+            rows.push(`| ${displayName} | ${backend} | ${contextStr} | ${effort} | ${formatCents(costCents)} | ${icon} | ${stateLabel} | ${ipc} |`);
         }
         if (rows.length === 0)
             return "No instances configured.";
         const lines = [
             "## Fleet Status",
             "",
-            "| Instance | Backend | Ctx | Cost | Status | State |",
-            "|----------|---------|-----|------|--------|-------|",
+            "| Instance | Backend | Ctx | Effort | Cost | Status | State | IPC |",
+            "|----------|---------|-----|--------|------|--------|-------|-----|",
             ...rows,
             "",
             `Paused instances: ${pausedCount}`,
@@ -512,63 +691,33 @@ export class TopicCommands {
         const text = this.getSysInfoText();
         await adapter.sendText(msg.chatId, text, { threadId: msg.threadId });
     }
-    /** Get system info as markdown text (shared by TG + DC) */
+    /**
+     * Get system info as markdown text (shared by TG + DC).
+     *
+     * 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".
+     */
     getSysInfoText() {
         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 lines = [
+        return [
             "## System Info",
             "",
             "| Metric | 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 |`,
-            "",
-            "## Instances",
-            "",
-            "| Name | State | IPC | Cost | Rate |",
-            "|------|-------|-----|------|------|",
-        ];
-        const fleetNames = new Set(info.instances.map(inst => inst.name));
-        const classicInstances = (this.ctx.classicChannels?.getAll() ?? [])
-            .filter(ch => !fleetNames.has(ch.instanceName))
-            .map(ch => ({
-            name: ch.instanceName,
-            status: this.ctx.getInstanceStatus(ch.instanceName),
-            state: this.ctx.getInstanceExecutionState?.(ch.instanceName) ?? null,
-            ipc: this.ctx.instanceIpcClients.has(ch.instanceName),
-            costCents: this.ctx.costGuard?.getDailyCostCents(ch.instanceName) ?? 0,
-            rateLimits: null,
-            classic: true,
-        }));
-        const instances = [
-            ...info.instances.map(inst => ({ ...inst, classic: false })),
-            ...classicInstances,
-        ];
-        for (const inst of instances) {
-            const executionState = inst.state;
-            const displayState = inst.status === "paused" ? "paused"
-                : inst.status === "stopped" || inst.status === "crashed" ? inst.status
-                    : executionState ?? "running";
-            const icon = displayState === "idle" ? "🟢"
-                : displayState === "working" ? "🔵"
-                    : displayState === "stuck" || displayState === "crashed" ? "🔴"
-                        : displayState === "paused" ? "⏸"
-                            : displayState === "stopped" ? "⚪" : "🟢";
-            const ipc = inst.ipc ? "✓" : "✗";
-            const rate = inst.rateLimits ? `5h:${inst.rateLimits.five_hour_pct}%` : "-";
-            const displayName = this.shortInstanceName(inst.name);
-            lines.push(`| ${icon} ${displayName} | ${displayState} | ${ipc} | ${formatCents(inst.costCents)} | ${rate} |`);
-        }
-        if (info.fleet_cost_limit_cents > 0) {
-            lines.push("", `Fleet cost: ${formatCents(info.fleet_cost_cents)} / ${formatCents(info.fleet_cost_limit_cents)} daily`);
-        }
-        return lines.join("\n");
+        ].join("\n");
     }
     async handleUpdateCommand(msg) {
         const adapter = this.getReplyAdapter(msg);
@@ -605,17 +754,26 @@ export class TopicCommands {
             return;
         }
         await adapter.sendText(chatId, t("doctor.running"), { threadId });
+        // Async, and execFile rather than a shell string: as execSync this froze the
+        // whole fleet event loop for up to 30s — no IPC, no delivery, no WATCHDOG
+        // ping — and any allowlisted user could trigger it with /doctor.
+        const stripAnsi = (s) => s.replace(/\x1b\[[0-9;]*[a-zA-Z]/g, "");
+        const backend = this.ctx.fleetConfig?.defaults?.backend || "claude-code";
+        let output;
         try {
-            const { execSync } = await import("node:child_process");
-            const backend = this.ctx.fleetConfig?.defaults?.backend || "claude-code";
-            const result = execSync(`agend backend doctor ${backend}`, { timeout: 30_000, encoding: "utf-8" });
-            const clean = result.replace(/\x1b\[[0-9;]*[a-zA-Z]/g, "");
-            await adapter.sendText(chatId, clean || "No output", { threadId });
+            const { execFile } = await import("node:child_process");
+            const { promisify } = await import("node:util");
+            const { stdout } = await promisify(execFile)("agend", ["backend", "doctor", backend], {
+                timeout: 30_000,
+                encoding: "utf-8",
+            });
+            output = stripAnsi(stdout) || "No output";
         }
         catch (err) {
-            const output = (err.stdout ?? err.message ?? "Doctor failed").replace(/\x1b\[[0-9;]*[a-zA-Z]/g, "");
-            await adapter.sendText(chatId, output, { threadId });
+            const e = err;
+            output = stripAnsi(e.stdout ?? e.message ?? "Doctor failed");
         }
+        await adapter.sendText(chatId, output, { threadId });
     }
     /** Reply with redirect when message arrives in an unbound topic */
     async handleUnboundTopic(msg) {
@@ -734,18 +892,20 @@ export class TopicCommands {
                     headers: { "Content-Type": "application/json" },
                     body: JSON.stringify({
                         commands: [
-                            { command: "status", description: "Show fleet status and costs" },
+                            { 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: "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" },
                         ],
                         scope: { type: "chat", chat_id: ch.group_id },
                     }),
@@ -760,6 +920,7 @@ export class TopicCommands {
                             { command: "stop", description: "🔒 Stop the agent" },
                             { command: "compact", description: "🔒 Compact agent 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" },