@nordbyte/nordrelay 0.3.1 → 0.4.1

package/dist/bot.js

@@ -8,23 +8,29 @@ import { hasTelegramPermission, permissionForCallbackData, permissionForCommand,
 import { buildFileInstructions, outboxPath, stageFile, } from "./attachments.js";
 import { collectArtifactReport, collectRecentWorkspaceArtifacts, createArtifactZipBundle, ensureOutDir, formatArtifactSummary, getArtifactTurnReport, isTelegramImagePreview, listRecentArtifactReports, persistWorkspaceArtifactReport, pruneConnectorTurnDirs, removeArtifactTurn, telegramArtifactFilename, totalArtifactSize, } from "./artifacts.js";
 import { listAgentAdapterDescriptors } from "./agent-adapter.js";
+import { AgentUpdateManager } from "./agent-updates.js";
 import { AuditLogStore } from "./audit-log.js";
 import { formatSessionLabel, renderHelpMessage, renderWelcomeFirstTime, renderWelcomeReturning, } from "./bot-ui.js";
 import { BotPreferencesStore, formatQuietHours, isQuietNow, parseMirrorMode, parseNotifyMode, parseQuietHours, parseVoiceBackendPreference, } from "./bot-preferences.js";
+import { logTailRequests, parseAgentUpdateId, parseLogsCommand, renderAgentUpdateJobAction, renderAgentUpdateJobsAction, renderAgentUpdateLogAction, renderAgentUpdatePickerAction, renderAgentsAction, renderArtifactReportsAction, renderChannelsAction, renderLogTailsAction, renderQueueListAction, renderQueuedPromptDetailAction, renderSelfUpdateStartedAction, } from "./channel-actions.js";
 import { listChannelDescriptors } from "./channel-adapter.js";
-import { CODEX_REASONING_EFFORTS, CODEX_AGENT_CAPABILITIES, PI_THINKING_LEVELS, agentLabel, agentReasoningLabel, } from "./agent.js";
+import { CODEX_AGENT_CAPABILITIES, agentLabel, agentReasoningLabel, agentReasoningOptions, } from "./agent.js";
+import { getAgentActivityLog, getAgentDiagnostics, getExternalActivityForSession, getExternalSnapshotForSession, } from "./agent-activity.js";
 import { enabledAgents } from "./agent-factory.js";
-import { checkAuthStatus, clearAuthCache, startLogin, startLogout } from "./codex-auth.js";
-import { findLaunchProfile, formatLaunchProfileBehavior, formatLaunchProfileLabel, } from "./codex-launch.js";
-import { getThreadActivity, getThreadActivityLog, getThreadRolloutSnapshot, } from "./codex-state.js";
+import { checkAuthStatus, clearAuthCache, startLogin as startCodexLogin, startLogout as startCodexLogout } from "./codex-auth.js";
+import { checkClaudeCodeAuthStatus, startClaudeCodeLogin, startClaudeCodeLogout } from "./claude-code-auth.js";
+import { formatLaunchProfileBehavior } from "./codex-launch.js";
 import { contextKeyFromCtx, isTelegramContextKey, isTopicContextKey, parseContextKey } from "./context-key.js";
 import { friendlyErrorText } from "./error-messages.js";
 import { escapeHTML, formatTelegramHTML } from "./format.js";
-import { getConnectorHealth, getUpdateLogPath, getVersionChecks, readConnectorState, readFormattedLogTail, spawnConnectorRestart, spawnSelfUpdate, } from "./operations.js";
+import { getConnectorHealth, getVersionChecks, readConnectorState, readFormattedLogTail, spawnConnectorRestart, spawnSelfUpdate, } from "./operations.js";
 import { PromptStore, toPromptEnvelope } from "./prompt-store.js";
+import { checkHermesAuthStatus, startHermesLogin, startHermesLogout } from "./hermes-auth.js";
+import { checkOpenClawAuthStatus } from "./openclaw-auth.js";
+import { checkPiAuthStatus } from "./pi-auth.js";
 import { configureRedaction, redactText } from "./redaction.js";
 import { canWriteWithLock, SessionLockStore } from "./session-locks.js";
-import { formatFileSize, renderLaunchSummaryHTML, renderLaunchSummaryPlain, renderSessionInfoHTML, renderSessionInfoPlain, } from "./session-format.js";
+import { renderLaunchSummaryHTML, renderLaunchSummaryPlain, renderSessionInfoHTML, renderSessionInfoPlain, } from "./session-format.js";
 import { SessionRegistry } from "./session-registry.js";
 import { getAvailableBackends, transcribeAudio } from "./voice.js";
 import { getTelegramRateLimitMetrics, telegramRateLimiter } from "./telegram-rate-limit.js";
@@ -63,6 +69,37 @@ function paginateKeyboard(items, page, prefix) {
     }
     return keyboard;
 }
+function actionKeyboard(rows) {
+    if (!rows || rows.length === 0) {
+        return undefined;
+    }
+    const keyboard = new InlineKeyboard();
+    for (const row of rows) {
+        for (const button of row) {
+            keyboard.text(button.label, telegramActionData(button.action));
+        }
+        keyboard.row();
+    }
+    return keyboard;
+}
+function telegramActionData(action) {
+    if (action === "agent-update:jobs") {
+        return "upd_jobs";
+    }
+    const agentUpdateStart = action.match(/^agent-update:start:(.+)$/);
+    if (agentUpdateStart?.[1]) {
+        return `upd_agent:${agentUpdateStart[1]}`;
+    }
+    const agentUpdateLog = action.match(/^agent-update:log:(.+)$/);
+    if (agentUpdateLog?.[1]) {
+        return `upd_log:${agentUpdateLog[1]}`;
+    }
+    const agentUpdateCancel = action.match(/^agent-update:cancel:(.+)$/);
+    if (agentUpdateCancel?.[1]) {
+        return `upd_cancel:${agentUpdateCancel[1]}`;
+    }
+    return action;
+}
 export function createBot(config, registry) {
     configureRedaction(config.telegramRedactPatterns);
     telegramRateLimiter.configure({
@@ -90,6 +127,7 @@ export function createBot(config, registry) {
     const preferencesStore = new BotPreferencesStore(config.workspace, config.stateBackend);
     const auditLog = new AuditLogStore(config.workspace, config.stateBackend, config.auditMaxEvents);
     const lockStore = new SessionLockStore(config.workspace, config.stateBackend);
+    const agentUpdates = new AgentUpdateManager();
     const drainingQueues = new Set();
     const externalQueueTimers = new Map();
     const externalMirrors = new Map();
@@ -97,23 +135,23 @@ export function createBot(config, registry) {
     const syncInterval = config.codexSyncIntervalMs > 0
         ? setInterval(() => {
             try {
-                registry.syncAllFromCodexState({ reattach: true });
+                registry.syncAllFromAgentState({ reattach: true });
             }
             catch (error) {
-                console.error("Failed to sync sessions from Codex state:", error);
+                console.error("Failed to sync sessions from agent state:", error);
             }
         }, config.codexSyncIntervalMs)
         : undefined;
     syncInterval?.unref?.();
     const externalMonitorInterval = setInterval(() => {
         void monitorExternalContexts().catch((error) => {
-            console.error("Failed to monitor external Codex activity:", error);
+            console.error("Failed to monitor external agent activity:", error);
         });
     }, config.codexExternalBusyCheckMs);
     externalMonitorInterval.unref?.();
     setTimeout(() => {
         void monitorExternalContexts().catch((error) => {
-            console.error("Failed to run initial external Codex monitor:", error);
+            console.error("Failed to run initial external agent monitor:", error);
         });
     }, 0).unref?.();
     registry.onRemove((key) => {
@@ -152,19 +190,7 @@ export function createBot(config, registry) {
         }
         return state;
     };
-    const getExternalActivity = (session) => {
-        const info = session?.getInfo();
-        if (!info || !capabilitiesOf(info).externalActivity) {
-            return null;
-        }
-        const threadId = session?.getActiveThreadId();
-        if (!threadId) {
-            return null;
-        }
-        return getThreadActivity(threadId, {
-            staleAfterMs: config.codexExternalBusyStaleMs,
-        });
-    };
+    const getExternalActivity = (session) => getExternalActivityForSession(session, config);
     const getBusyReason = (contextKey) => {
         const state = contextBusy.get(contextKey);
         const session = registry.get(contextKey);
@@ -191,6 +217,114 @@ export function createBot(config, registry) {
     const updateSessionMetadata = (contextKey, session) => {
         registry.updateMetadata(contextKey, session);
     };
+    const checkAgentAuthStatus = async (info) => {
+        if (idOf(info) === "pi") {
+            return checkPiAuthStatus(info.model);
+        }
+        if (idOf(info) === "hermes") {
+            return checkHermesAuthStatus({
+                baseUrl: config.hermesApiBaseUrl,
+                apiKey: config.hermesApiKey,
+            });
+        }
+        if (idOf(info) === "openclaw") {
+            return checkOpenClawAuthStatus({
+                gatewayUrl: config.openClawGatewayUrl,
+                token: config.openClawGatewayToken,
+                password: config.openClawGatewayPassword,
+            });
+        }
+        if (idOf(info) === "claude-code") {
+            return checkClaudeCodeAuthStatus(config.claudeCodeCliPath);
+        }
+        return checkAuthStatus(config.codexApiKey);
+    };
+    const agentIdForAuth = (info) => info ? idOf(info) : "codex";
+    const labelForAuth = (info) => info ? labelOf(info) : "Codex";
+    const checkLoginAuthStatus = async (info) => {
+        const agentId = agentIdForAuth(info);
+        if (agentId === "hermes") {
+            return checkHermesAuthStatus({
+                baseUrl: config.hermesApiBaseUrl,
+                apiKey: config.hermesApiKey,
+            });
+        }
+        if (agentId === "claude-code") {
+            return checkClaudeCodeAuthStatus(config.claudeCodeCliPath);
+        }
+        return checkAuthStatus(config.codexApiKey);
+    };
+    const agentUpdateContext = () => ({
+        piCliPath: config.piCliPath,
+        hermesCliPath: config.hermesCliPath,
+        openClawCliPath: config.openClawCliPath,
+        claudeCodeCliPath: config.claudeCodeCliPath,
+    });
+    const startTelegramAgentUpdate = async (ctx, agentId) => {
+        try {
+            const job = agentUpdates.start(agentId, agentUpdateContext());
+            const contextKey = contextKeyFromCtx(ctx);
+            if (contextKey) {
+                audit({
+                    action: "command",
+                    status: "ok",
+                    contextKey,
+                    agentId,
+                    description: `update ${agentId}`,
+                    detail: job.summary,
+                });
+            }
+            const rendered = renderAgentUpdateJobAction(job);
+            await safeReply(ctx, rendered.html, {
+                fallbackText: rendered.plain,
+                replyMarkup: actionKeyboard(rendered.buttons),
+            });
+        }
+        catch (error) {
+            const message = `Failed to start ${agentLabel(agentId)} update: ${friendlyErrorText(error)}`;
+            await safeReply(ctx, `<b>Update failed:</b> ${escapeHTML(message)}`, { fallbackText: message });
+        }
+    };
+    const startAgentLogin = (info) => {
+        const agentId = agentIdForAuth(info);
+        if (agentId === "hermes") {
+            return startHermesLogin(config.hermesCliPath);
+        }
+        if (agentId === "claude-code") {
+            return startClaudeCodeLogin(config.claudeCodeCliPath);
+        }
+        return startCodexLogin();
+    };
+    const startAgentLogout = (info) => {
+        const agentId = agentIdForAuth(info);
+        if (agentId === "hermes") {
+            return startHermesLogout(config.hermesCliPath);
+        }
+        if (agentId === "claude-code") {
+            return startClaudeCodeLogout(config.claudeCodeCliPath);
+        }
+        return startCodexLogout();
+    };
+    const hostLoginCommand = (info) => {
+        const agentId = agentIdForAuth(info);
+        if (agentId === "hermes") {
+            return `${config.hermesCliPath ?? "hermes"} login --no-browser`;
+        }
+        if (agentId === "claude-code") {
+            return `${config.claudeCodeCliPath ?? "claude"} auth login`;
+        }
+        return "codex login --device-auth";
+    };
+    const hostLogoutCommand = (info) => {
+        const agentId = agentIdForAuth(info);
+        if (agentId === "hermes") {
+            return `${config.hermesCliPath ?? "hermes"} logout`;
+        }
+        if (agentId === "claude-code") {
+            return `${config.claudeCodeCliPath ?? "claude"} auth logout`;
+        }
+        return "codex logout";
+    };
     const isTopicContext = (contextKey) => isTopicContextKey(contextKey);
     const getPreferences = (contextKey) => preferencesStore.get(contextKey);
     const getEffectiveMirrorMode = (contextKey) => getPreferences(contextKey).mirrorMode ?? config.telegramMirrorMode;
@@ -255,22 +389,10 @@ export function createBot(config, registry) {
     const createQueuedPromptCancelKeyboard = (contextKey, queueId, label = "Cancel queued message") => new InlineKeyboard().text(label, queueCancelCallbackData("cancel", contextKey, queueId));
     const renderQueueList = (contextKey, queue) => {
         const paused = promptStore.isPaused(contextKey);
+        const rendered = renderQueueListAction(queue, paused);
         if (queue.length === 0) {
-            return {
-                plain: paused ? "Queue is empty and paused." : "Queue is empty.",
-                html: escapeHTML(paused ? "Queue is empty and paused." : "Queue is empty."),
-            };
+            return rendered;
         }
-        const lines = queue.map((item, index) => {
-            const age = formatRelativeTime(new Date(item.createdAt));
-            const attempts = item.attempts && item.attempts > 0 ? ` · attempts ${item.attempts}` : "";
-            const error = item.lastError ? ` · last error: ${trimLine(item.lastError, 80)}` : "";
-            const scheduled = item.notBefore && item.notBefore > Date.now()
-                ? `scheduled ${formatLocalDateTime(new Date(item.notBefore))}`
-                : index === 0 ? "next" : `after ${index} queued item${index === 1 ? "" : "s"}`;
-            const eta = scheduled;
-            return `${index + 1}. ${item.id} · ${age} · ${eta}${attempts}${error} · ${item.description}`;
-        });
         const keyboard = new InlineKeyboard();
         queue.forEach((item, index) => {
             keyboard
@@ -283,11 +405,7 @@ export function createBot(config, registry) {
                 .text("Down", queueCancelCallbackData("down", contextKey, item.id))
                 .row();
         });
-        return {
-            plain: [paused ? "Queued prompts (paused):" : "Queued prompts:", ...lines].join("\n"),
-            html: [paused ? "<b>Queued prompts:</b> <code>paused</code>" : "<b>Queued prompts:</b>", ...lines.map(escapeHTML)].join("\n"),
-            keyboard,
-        };
+        return { ...rendered, keyboard };
     };
     const createSystemContext = (contextKey) => {
         const parsed = parseContextKey(contextKey);
@@ -364,11 +482,9 @@ export function createBot(config, registry) {
             return;
         }
         const previous = externalMirrors.get(contextKey);
-        const snapshot = getThreadRolloutSnapshot(threadId, {
+        const snapshot = getExternalSnapshotForSession(session, config, {
             afterLine: previous?.lastLine ?? Number.MAX_SAFE_INTEGER,
-            staleAfterMs: config.codexExternalBusyStaleMs,
-        }) ?? getThreadRolloutSnapshot(threadId, {
-            staleAfterMs: config.codexExternalBusyStaleMs,
+        }) ?? getExternalSnapshotForSession(session, config, {
             maxEvents: 0,
         });
         if (!snapshot) {
@@ -382,7 +498,7 @@ export function createBot(config, registry) {
         }
         const activity = snapshot.activity;
         if (activity.active && queueLength > 0) {
-            await updateQueueStatusMessage(contextKey, `Waiting for Codex CLI task... ${queueLength} queued${paused ? " (paused)" : ""}.`);
+            await updateQueueStatusMessage(contextKey, `Waiting for ${info.agentLabel} CLI task... ${queueLength} queued${paused ? " (paused)" : ""}.`);
             return;
         }
         if (!activity.active && queueLength > 0 && !paused && !session.isProcessing()) {
@@ -394,10 +510,10 @@ export function createBot(config, registry) {
         const parsed = parseContextKey(contextKey);
         const previous = externalMirrors.get(contextKey);
         let state = previous;
-        if (!state || state.threadId !== snapshot.threadId || state.rolloutPath !== snapshot.rolloutPath) {
+        if (!state || state.threadId !== snapshot.threadId || state.rolloutPath !== snapshot.sourcePath) {
             state = {
                 threadId: snapshot.threadId,
-                rolloutPath: snapshot.rolloutPath,
+                rolloutPath: snapshot.sourcePath,
                 lastLine: snapshot.lineCount,
                 turnId: snapshot.activity.turnId,
                 startedAt: snapshot.activity.startedAt,
@@ -458,7 +574,7 @@ export function createBot(config, registry) {
         const terminalEvent = [...snapshot.events].reverse().find((event) => event.kind === "task" && event.status && event.status !== "started");
         if (terminalEvent) {
             if (mirrorMode !== "off") {
-                const doneText = `Codex CLI task ${terminalEvent.status}.`;
+                const doneText = `${snapshot.agentLabel} CLI task ${terminalEvent.status}.`;
                 if (state.statusMessageId) {
                     await safeEditMessage(bot, chatId, state.statusMessageId, escapeHTML(doneText), {
                         fallbackText: doneText,
@@ -473,8 +589,8 @@ export function createBot(config, registry) {
             }
             const finalAgent = snapshot.events.filter((event) => event.kind === "agent" && event.text).at(-1);
             if (mirrorMode !== "off" && mirrorMode !== "status" && finalAgent?.text && finalAgent.lineNumber !== state.latestAgentLine) {
-                await sendTextMessage(bot.api, chatId, "<b>Codex CLI final answer:</b>", {
-                    fallbackText: "Codex CLI final answer:",
+                await sendTextMessage(bot.api, chatId, `<b>${escapeHTML(snapshot.agentLabel)} CLI final answer:</b>`, {
+                    fallbackText: `${snapshot.agentLabel} CLI final answer:`,
                     messageThreadId: parsed.messageThreadId,
                 });
                 for (const chunk of splitMarkdownForTelegram(finalAgent.text)) {
@@ -544,7 +660,8 @@ export function createBot(config, registry) {
                 }
                 const busy = getBusyReason(contextKey);
                 if (busy.kind === "external") {
-                    await updateQueueStatusMessage(contextKey, `Waiting for Codex CLI task... ${promptStore.list(contextKey).length} queued${promptStore.isPaused(contextKey) ? " (paused)" : ""}.`);
+                    const label = busy.activity.agentLabel;
+                    await updateQueueStatusMessage(contextKey, `Waiting for ${label} CLI task... ${promptStore.list(contextKey).length} queued${promptStore.isPaused(contextKey) ? " (paused)" : ""}.`);
                     scheduleExternalQueueDrain(ctx, contextKey, chatId, session);
                     return;
                 }
@@ -554,7 +671,7 @@ export function createBot(config, registry) {
                 await updateQueueStatusMessage(contextKey, `CLI task finished, running queued prompt 1/${promptStore.list(contextKey).length}.`);
                 await drainQueuedPrompts(ctx, contextKey, chatId, session);
             })().catch((error) => {
-                console.error("Failed to drain queue after external Codex activity:", error);
+                console.error("Failed to drain queue after external CLI activity:", error);
             });
         }, config.codexExternalBusyCheckMs);
         timer.unref?.();
@@ -1109,21 +1226,21 @@ export function createBot(config, registry) {
         try {
             const sessionInfo = session.getInfo();
             if (capabilitiesOf(sessionInfo).auth) {
-                const authStatus = await checkAuthStatus(config.codexApiKey);
+                const authStatus = await checkAgentAuthStatus(sessionInfo);
                 if (!authStatus.authenticated) {
                     await safeReply(ctx, [
                         `<b>⚠️ ${escapeHTML(labelOf(sessionInfo))} is not authenticated.</b>`,
                         "",
                         `<code>${escapeHTML(authStatus.detail)}</code>`,
                         "",
-                        "Use /login to start authentication, or set CODEX_API_KEY on the host.",
+                        authHelpText(sessionInfo),
                     ].join("\n"), {
                         fallbackText: [
                             `⚠️ ${labelOf(sessionInfo)} is not authenticated.`,
                             "",
                             authStatus.detail,
                             "",
-                            "Use /login to start authentication, or set CODEX_API_KEY on the host.",
+                            authHelpText(sessionInfo),
                         ].join("\n"),
                     });
                     return;
@@ -1135,6 +1252,24 @@ export function createBot(config, registry) {
                 });
                 return;
             }
+            if (idOf(sessionInfo) === "hermes" && !config.hermesEnabled) {
+                await safeReply(ctx, "<b>⚠️ Hermes is disabled.</b>\nEnable it with <code>NORDRELAY_HERMES_ENABLED=true</code>.", {
+                    fallbackText: "⚠️ Hermes is disabled.\nEnable it with NORDRELAY_HERMES_ENABLED=true.",
+                });
+                return;
+            }
+            if (idOf(sessionInfo) === "openclaw" && !config.openClawEnabled) {
+                await safeReply(ctx, "<b>⚠️ OpenClaw is disabled.</b>\nEnable it with <code>NORDRELAY_OPENCLAW_ENABLED=true</code>.", {
+                    fallbackText: "⚠️ OpenClaw is disabled.\nEnable it with NORDRELAY_OPENCLAW_ENABLED=true.",
+                });
+                return;
+            }
+            if (idOf(sessionInfo) === "claude-code" && !config.claudeCodeEnabled) {
+                await safeReply(ctx, "<b>⚠️ Claude Code is disabled.</b>\nEnable it with <code>NORDRELAY_CLAUDE_CODE_ENABLED=true</code>.", {
+                    fallbackText: "⚠️ Claude Code is disabled.\nEnable it with NORDRELAY_CLAUDE_CODE_ENABLED=true.",
+                });
+                return;
+            }
             if (!(await ensureActiveThread(ctx, contextKey, session))) {
                 return;
             }
@@ -1148,12 +1283,13 @@ export function createBot(config, registry) {
             const finalExternalActivity = getExternalActivity(session);
             if (finalExternalActivity?.active) {
                 const item = maybeRequeuePromptAtFront(contextKey, envelope);
-                const message = `Queued prompt ${item.id} at position 1. The Codex session became active in Codex CLI and is processing another task.`;
+                const label = finalExternalActivity.agentLabel;
+                const message = `Queued prompt ${item.id} at position 1. The ${label} session became active in ${label} CLI and is processing another task.`;
                 await safeReply(ctx, escapeHTML(message), {
                     fallbackText: message,
                     replyMarkup: createQueuedPromptCancelKeyboard(contextKey, item.id),
                 });
-                await updateQueueStatusMessage(contextKey, `Waiting for Codex CLI task... ${promptStore.list(contextKey).length} queued.`);
+                await updateQueueStatusMessage(contextKey, `Waiting for ${label} CLI task... ${promptStore.list(contextKey).length} queued.`);
                 scheduleExternalQueueDrain(ctx, contextKey, chatId, session);
                 turnProgress.delete(contextKey);
                 return;
@@ -1164,9 +1300,14 @@ export function createBot(config, registry) {
                 status: "ok",
                 description: envelope.description,
             });
+            const artifactStartedAt = new Date();
+            const artifactTurnId = envelope.artifactOutDir
+                ? path.basename(path.dirname(envelope.artifactOutDir))
+                : randomUUID().slice(0, 12);
             await session.prompt(envelope.input, callbacks);
             updateSessionMetadata(contextKey, session);
             await finalizeResponse();
+            await deliverCliGeneratedArtifacts(contextKey, chatId, session, artifactStartedAt, artifactTurnId, messageThreadId);
             if (envelope.artifactOutDir) {
                 if (config.telegramAutoSendArtifacts) {
                     await deliverArtifacts(ctx, chatId, envelope.artifactOutDir, session.getInfo().workspace, messageThreadId);
@@ -1321,7 +1462,7 @@ export function createBot(config, registry) {
     const deliverArtifactReportZip = async (ctx, chatId, report, messageThreadId) => {
         const bundle = await createArtifactZipBundle(report.artifacts, report.outDir, {
             maxFileSize: config.maxFileSize,
-            bundleName: `codex-artifacts-${report.turnId}.zip`,
+            bundleName: `nordrelay-artifacts-${report.turnId}.zip`,
         });
         if (!bundle) {
             await safeReply(ctx, escapeHTML("Could not create a ZIP bundle for this artifact turn."), {
@@ -1516,9 +1657,9 @@ export function createBot(config, registry) {
         }
         const { contextKey, session } = contextSession;
         const info = session.getInfo();
-        const authStatus = capabilitiesOf(info).auth ? await checkAuthStatus(config.codexApiKey) : null;
+        const authStatus = capabilitiesOf(info).auth ? await checkAgentAuthStatus(info) : null;
         const authWarning = authStatus && !authStatus.authenticated
-            ? "Not authenticated. Use /login or set CODEX_API_KEY."
+            ? [`${labelOf(info)} is not authenticated.`, authStatus.detail, authHelpText(info)].filter(Boolean).join(" ")
             : undefined;
         const isReturning = registry.hasMetadata(contextKey);
         if (isReturning) {
@@ -1537,48 +1678,12 @@ export function createBot(config, registry) {
         await safeReply(ctx, help.html, { fallbackText: help.plain });
     });
     bot.command("channels", async (ctx) => {
-        const descriptors = listChannelDescriptors();
-        const lines = descriptors.map((descriptor) => {
-            const status = descriptor.status === "available" ? "available" : "planned";
-            return `${descriptor.label}: ${status} · ${descriptor.capabilities.join(", ")}`;
-        });
-        const html = [
-            "<b>Channel adapters:</b>",
-            ...descriptors.map((descriptor) => {
-                const statusIcon = descriptor.status === "available" ? "✅" : "🟡";
-                const notes = descriptor.notes ? `\n  ${escapeHTML(descriptor.notes)}` : "";
-                return `${statusIcon} <b>${escapeHTML(descriptor.label)}</b> <code>${escapeHTML(descriptor.status)}</code>\n  <code>${escapeHTML(descriptor.capabilities.join(", "))}</code>${notes}`;
-            }),
-        ].join("\n");
-        await safeReply(ctx, html, { fallbackText: ["Channel adapters:", ...lines].join("\n") });
+        const rendered = renderChannelsAction(listChannelDescriptors());
+        await safeReply(ctx, rendered.html, { fallbackText: rendered.plain });
     });
     bot.command("agents", async (ctx) => {
-        const descriptors = listAgentAdapterDescriptors();
-        const plain = [
-            "Agent adapters:",
-            ...descriptors.map((descriptor) => {
-                const enabled = descriptor.id === "codex"
-                    ? config.codexEnabled
-                    : descriptor.id === "pi"
-                        ? config.piEnabled
-                        : false;
-                return `${descriptor.label}: ${descriptor.status}${descriptor.status === "available" ? ` · ${enabled ? "enabled" : "disabled"}` : ""}`;
-            }),
-        ].join("\n");
-        const html = [
-            "<b>Agent adapters:</b>",
-            ...descriptors.map((descriptor) => {
-                const enabled = descriptor.id === "codex"
-                    ? config.codexEnabled
-                    : descriptor.id === "pi"
-                        ? config.piEnabled
-                        : false;
-                const status = descriptor.status === "available" ? `${enabled ? "enabled" : "disabled"}` : "planned";
-                const notes = descriptor.notes ? `\n  ${escapeHTML(descriptor.notes)}` : "";
-                return `${descriptor.status === "available" ? "✅" : "🟡"} <b>${escapeHTML(descriptor.label)}</b> <code>${escapeHTML(status)}</code>${notes}`;
-            }),
-        ].join("\n");
-        await safeReply(ctx, html, { fallbackText: plain });
+        const rendered = renderAgentsAction(listAgentAdapterDescriptors(), enabledAgents(config));
+        await safeReply(ctx, rendered.html, { fallbackText: rendered.plain });
     });
     bot.command("agent", async (ctx) => {
         const contextSession = await getContextSession(ctx, { deferThreadStart: true });
@@ -1586,11 +1691,6 @@ export function createBot(config, registry) {
             return;
         }
         const { contextKey, session } = contextSession;
-        if (!capabilitiesOf(session.getInfo()).modelSelection) {
-            const text = `Model selection is not supported for ${labelOf(session.getInfo())}.`;
-            await safeReply(ctx, escapeHTML(text), { fallbackText: text });
-            return;
-        }
         if (isBusy(contextKey)) {
             await safeReply(ctx, escapeHTML("Cannot switch agent while a prompt is running."), {
                 fallbackText: "Cannot switch agent while a prompt is running.",
@@ -1627,7 +1727,7 @@ export function createBot(config, registry) {
             await safeReply(ctx, escapeHTML(text), { fallbackText: text });
             return;
         }
-        const authStatus = await checkAuthStatus(config.codexApiKey);
+        const authStatus = info ? await checkAgentAuthStatus(info) : await checkAuthStatus(config.codexApiKey);
         const icon = authStatus.authenticated ? "✅" : "❌";
         const html = [
             `<b>${icon} Auth status:</b> ${authStatus.authenticated ? "authenticated" : "not authenticated"}`,
@@ -1652,8 +1752,8 @@ export function createBot(config, registry) {
             await safeReply(ctx, escapeHTML(text), { fallbackText: text });
             return;
         }
-        const authStatus = await checkAuthStatus(config.codexApiKey);
-        if (authStatus.authenticated) {
+        const authStatus = await checkLoginAuthStatus(info);
+        if (agentIdForAuth(info) !== "hermes" && authStatus.authenticated) {
             await safeReply(ctx, `<b>✅ Already authenticated</b> via <code>${escapeHTML(authStatus.method)}</code>.`, {
                 fallbackText: `✅ Already authenticated via ${authStatus.method}.`,
             });
@@ -1663,17 +1763,17 @@ export function createBot(config, registry) {
             await safeReply(ctx, [
                 "<b>Telegram-initiated login is disabled.</b>",
                 "",
-                "Run <code>codex login</code> on the host, or set CODEX_API_KEY in .env.",
+                `Run <code>${escapeHTML(hostLoginCommand(info))}</code> on the host.`,
             ].join("\n"), {
                 fallbackText: [
                     "Telegram-initiated login is disabled.",
                     "",
-                    "Run 'codex login' on the host, or set CODEX_API_KEY in .env.",
+                    `Run '${hostLoginCommand(info)}' on the host.`,
                 ].join("\n"),
             });
             return;
         }
-        const result = await startLogin();
+        const result = await startAgentLogin(info);
         if (result.success) {
             await safeReply(ctx, `<b>🔑 Login initiated.</b>\n\n<code>${escapeHTML(result.message)}</code>`, {
                 fallbackText: `🔑 Login initiated.\n\n${result.message}`,
@@ -1695,17 +1795,17 @@ export function createBot(config, registry) {
             await safeReply(ctx, escapeHTML(text), { fallbackText: text });
             return;
         }
-        const authStatus = await checkAuthStatus(config.codexApiKey);
+        const authStatus = await checkLoginAuthStatus(info);
         if (authStatus.method === "api-key") {
             await safeReply(ctx, [
-                "<b>Cannot logout via Telegram when using CODEX_API_KEY.</b>",
+                `<b>Cannot logout via Telegram when ${escapeHTML(labelForAuth(info))} uses API-key authentication.</b>`,
                 "",
-                "Remove CODEX_API_KEY from .env to use CLI-based auth instead.",
+                "Remove the API key from .env to use CLI-based auth instead.",
             ].join("\n"), {
                 fallbackText: [
-                    "Cannot logout via Telegram when using CODEX_API_KEY.",
+                    `Cannot logout via Telegram when ${labelForAuth(info)} uses API-key authentication.`,
                     "",
-                    "Remove CODEX_API_KEY from .env to use CLI-based auth instead.",
+                    "Remove the API key from .env to use CLI-based auth instead.",
                 ].join("\n"),
             });
             return;
@@ -1714,23 +1814,23 @@ export function createBot(config, registry) {
             await safeReply(ctx, [
                 "<b>Telegram-initiated auth management is disabled.</b>",
                 "",
-                "Run <code>codex logout</code> on the host.",
+                `Run <code>${escapeHTML(hostLogoutCommand(info))}</code> on the host.`,
             ].join("\n"), {
                 fallbackText: [
                     "Telegram-initiated auth management is disabled.",
                     "",
-                    "Run 'codex logout' on the host.",
+                    `Run '${hostLogoutCommand(info)}' on the host.`,
                 ].join("\n"),
             });
             return;
         }
-        if (!authStatus.authenticated) {
+        if (agentIdForAuth(info) !== "hermes" && !authStatus.authenticated) {
             await safeReply(ctx, escapeHTML("Not currently authenticated."), {
                 fallbackText: "Not currently authenticated.",
             });
             return;
         }
-        const result = await startLogout();
+        const result = await startAgentLogout(info);
         if (result.success) {
             await safeReply(ctx, `<b>🔓 Logged out.</b>\n\n${escapeHTML(result.message)}`, {
                 fallbackText: `🔓 Logged out.\n\n${result.message}`,
@@ -1931,16 +2031,19 @@ export function createBot(config, registry) {
         });
     });
     bot.command(["status", "health"], async (ctx) => {
-        const health = await getConnectorHealth();
-        const authStatus = await checkAuthStatus(config.codexApiKey);
+        const health = await getConnectorHealth({ piCliPath: config.piCliPath, hermesCliPath: config.hermesCliPath, openClawCliPath: config.openClawCliPath, claudeCodeCliPath: config.claudeCodeCliPath });
+        const contextSession = await getContextSession(ctx, { deferThreadStart: true });
+        const authStatus = contextSession
+            ? await checkAgentAuthStatus(contextSession.session.getInfo())
+            : await checkAuthStatus(config.codexApiKey);
         const html = renderHealthHTML(health, authStatus.authenticated, getUserRole(ctx));
         const plain = renderHealthPlain(health, authStatus.authenticated, getUserRole(ctx));
         await safeReply(ctx, html, { fallbackText: plain });
     });
     bot.command("version", async (ctx) => {
-        const health = await getConnectorHealth();
+        const health = await getConnectorHealth({ piCliPath: config.piCliPath, hermesCliPath: config.hermesCliPath, openClawCliPath: config.openClawCliPath, claudeCodeCliPath: config.claudeCodeCliPath });
         const state = await readConnectorState();
-        const versions = await getVersionChecks({ piCliPath: config.piCliPath });
+        const versions = await getVersionChecks({ piCliPath: config.piCliPath, hermesCliPath: config.hermesCliPath, openClawCliPath: config.openClawCliPath, claudeCodeCliPath: config.claudeCodeCliPath });
         const plain = [
             renderVersionCheckPlain(versions.nordrelay),
             `Runtime status: ${state.status ?? "unknown"}`,
@@ -1948,6 +2051,12 @@ export function createBot(config, registry) {
             renderVersionCheckPlain(versions.codex),
             formatCliPathPlain("Pi CLI", health.piCliPath, health.piCli),
             renderVersionCheckPlain(versions.pi),
+            formatCliPathPlain("Hermes CLI", health.hermesCliPath, health.hermesCli),
+            renderVersionCheckPlain(versions.hermes),
+            formatCliPathPlain("OpenClaw CLI", health.openClawCliPath, health.openClawCli),
+            renderVersionCheckPlain(versions.openclaw),
+            formatCliPathPlain("Claude Code CLI", health.claudeCodeCliPath, health.claudeCodeCli),
+            renderVersionCheckPlain(versions.claudeCode),
         ].join("\n");
         const html = [
             renderVersionCheckHTML(versions.nordrelay),
@@ -1956,6 +2065,12 @@ export function createBot(config, registry) {
             renderVersionCheckHTML(versions.codex),
             formatCliPathHTML("Pi CLI", health.piCliPath, health.piCli),
             renderVersionCheckHTML(versions.pi),
+            formatCliPathHTML("Hermes CLI", health.hermesCliPath, health.hermesCli),
+            renderVersionCheckHTML(versions.hermes),
+            formatCliPathHTML("OpenClaw CLI", health.openClawCliPath, health.openClawCli),
+            renderVersionCheckHTML(versions.openclaw),
+            formatCliPathHTML("Claude Code CLI", health.claudeCodeCliPath, health.claudeCodeCli),
+            renderVersionCheckHTML(versions.claudeCode),
         ].join("\n");
         await safeReply(ctx, html, { fallbackText: plain });
     });
@@ -1993,10 +2108,10 @@ export function createBot(config, registry) {
             return;
         }
         const options = parseActivityOptions((ctx.message?.text ?? "").replace(/^\/activity(?:@\w+)?\s*/i, "").trim());
-        const events = filterActivityEvents(getThreadActivityLog(threadId, options.exportFile ? 200 : options.limit), options);
+        const events = filterActivityEvents(getAgentActivityLog(contextSession.session, config, options.exportFile ? 200 : options.limit), options);
         const rendered = renderActivityTimeline(threadId, events, options);
         if (options.exportFile && ctx.chat) {
-            const exportPath = path.join(tmpdir(), `codex-activity-${threadId}-${randomUUID().slice(0, 8)}.txt`);
+            const exportPath = path.join(tmpdir(), `nordrelay-activity-${threadId}-${randomUUID().slice(0, 8)}.txt`);
             await writeFile(exportPath, rendered.plain, "utf8");
             try {
                 await telegramRateLimiter.run(chatBucket(ctx.chat.id), "sendDocument", () => ctx.api.sendDocument(ctx.chat.id, new InputFile(exportPath, path.basename(exportPath)), {
@@ -2066,15 +2181,17 @@ export function createBot(config, registry) {
         await safeReply(ctx, rendered.html, { fallbackText: rendered.plain });
     });
     bot.command("diagnostics", async (ctx) => {
-        const health = await getConnectorHealth();
-        const authStatus = await checkAuthStatus(config.codexApiKey);
+        const health = await getConnectorHealth({ piCliPath: config.piCliPath, hermesCliPath: config.hermesCliPath, openClawCliPath: config.openClawCliPath, claudeCodeCliPath: config.claudeCodeCliPath });
         const contextKey = contextKeyFromCtx(ctx);
         const queueLength = contextKey ? promptStore.list(contextKey).length : 0;
         const progress = contextKey ? turnProgress.get(contextKey) : undefined;
         const contextSession = contextKey ? await getContextSession(ctx, { deferThreadStart: true }) : null;
-        const rolloutDiagnostics = contextSession && capabilitiesOf(contextSession.session.getInfo()).externalActivity
-            ? renderRolloutDiagnostics(contextSession.session.getActiveThreadId(), config.codexExternalBusyStaleMs)
-            : { plain: "Rollout: no context", html: "<b>Rollout:</b> <code>no context</code>" };
+        const authStatus = contextSession
+            ? await checkAgentAuthStatus(contextSession.session.getInfo())
+            : await checkAuthStatus(config.codexApiKey);
+        const agentDiagnostics = contextSession
+            ? renderAgentDiagnostics(getAgentDiagnostics(contextSession.session, config))
+            : { plain: "Agent state: no context", html: "<b>Agent state:</b> <code>no context</code>" };
         const runtime = {
             rateLimit: getTelegramRateLimitMetrics(),
             externalMirrors: externalMirrors.size,
@@ -2087,8 +2204,8 @@ export function createBot(config, registry) {
             voiceLanguage: contextKey ? getEffectiveVoiceLanguage(contextKey) ?? "auto" : config.voiceDefaultLanguage ?? "auto",
             voiceTranscribeOnly: contextKey ? isVoiceTranscribeOnly(contextKey) : config.voiceTranscribeOnly,
         };
-        const plain = `${renderDiagnosticsPlain(config, registry, health, authStatus.authenticated, getUserRole(ctx), queueLength, progress, runtime)}\n${rolloutDiagnostics.plain}`;
-        const html = `${renderDiagnosticsHTML(config, registry, health, authStatus.authenticated, getUserRole(ctx), queueLength, progress, runtime)}\n${rolloutDiagnostics.html}`;
+        const plain = `${renderDiagnosticsPlain(config, registry, health, authStatus.authenticated, getUserRole(ctx), queueLength, progress, runtime)}\n${agentDiagnostics.plain}`;
+        const html = `${renderDiagnosticsHTML(config, registry, health, authStatus.authenticated, getUserRole(ctx), queueLength, progress, runtime)}\n${agentDiagnostics.html}`;
         await safeReply(ctx, html, { fallbackText: plain });
     });
     bot.command("sync", async (ctx) => {
@@ -2103,7 +2220,7 @@ export function createBot(config, registry) {
             await safeReply(ctx, html, { fallbackText: plain });
             return;
         }
-        const result = contextSession.session.syncFromCodexState({ reattach: true });
+        const result = contextSession.session.syncFromAgentState({ reattach: true });
         if (result.changed) {
             updateSessionMetadata(contextSession.contextKey, contextSession.session);
         }
@@ -2128,20 +2245,12 @@ export function createBot(config, registry) {
         const rawText = ctx.message?.text ?? "";
         const argument = rawText.replace(/^\/logs(?:@\w+)?\s*/i, "").trim();
         const logRequest = parseLogsCommand(argument);
-        const logs = logRequest.target === "all"
-            ? [
-                { title: "Connector", tail: await readFormattedLogTail(logRequest.lines) },
-                { title: "Update", tail: await readFormattedLogTail(logRequest.lines, getUpdateLogPath()) },
-            ]
-            : [
-                {
-                    title: logRequest.target === "update" ? "Update" : "Connector",
-                    tail: await readFormattedLogTail(logRequest.lines, logRequest.target === "update" ? getUpdateLogPath() : undefined),
-                },
-            ];
-        const plain = logs.map(({ title, tail }) => renderLogTailPlain(title, tail)).join("\n\n");
-        const html = logs.map(({ title, tail }) => renderLogTailHTML(title, tail)).join("\n\n");
-        await safeReply(ctx, html, { fallbackText: plain });
+        const logs = await Promise.all(logTailRequests(logRequest.target).map(async (request) => ({
+            title: request.title,
+            tail: await readFormattedLogTail(logRequest.lines, request.path),
+        })));
+        const rendered = renderLogTailsAction(logs);
+        await safeReply(ctx, rendered.html, { fallbackText: rendered.plain });
     });
     bot.command("restart", async (ctx) => {
         await safeReply(ctx, escapeHTML("Restarting connector..."), {
@@ -2152,24 +2261,92 @@ export function createBot(config, registry) {
         }, 300);
     });
     bot.command("update", async (ctx) => {
+        const rawText = ctx.message?.text ?? "";
+        const argument = rawText.replace(/^\/update(?:@\w+)?\s*/i, "").trim();
+        const tokens = argument.split(/\s+/).filter(Boolean);
+        const subcommand = tokens[0]?.toLowerCase();
+        if (subcommand === "agents" || subcommand === "agent") {
+            const rendered = renderAgentUpdatePickerAction(listAgentAdapterDescriptors());
+            await safeReply(ctx, rendered.html, { fallbackText: rendered.plain, replyMarkup: actionKeyboard(rendered.buttons) });
+            return;
+        }
+        if (subcommand === "jobs" || subcommand === "status") {
+            const rendered = renderAgentUpdateJobsAction(agentUpdates.list());
+            await safeReply(ctx, rendered.html, { fallbackText: rendered.plain });
+            return;
+        }
+        if (subcommand === "log" && tokens[1]) {
+            const rendered = renderAgentUpdateLogAction(agentUpdates.readLog(tokens[1]));
+            await safeReply(ctx, rendered.html, { fallbackText: rendered.plain });
+            return;
+        }
+        if (subcommand === "cancel" && tokens[1]) {
+            const job = agentUpdates.cancel(tokens[1]);
+            const rendered = renderAgentUpdateJobAction(job);
+            await safeReply(ctx, rendered.html, {
+                fallbackText: rendered.plain,
+                replyMarkup: actionKeyboard(rendered.buttons),
+            });
+            return;
+        }
+        if ((subcommand === "input" || subcommand === "send") && tokens[1] && tokens.slice(2).join(" ").trim()) {
+            const job = agentUpdates.sendInput(tokens[1], tokens.slice(2).join(" "));
+            const rendered = renderAgentUpdateJobAction(job);
+            await safeReply(ctx, rendered.html, {
+                fallbackText: rendered.plain,
+                replyMarkup: actionKeyboard(rendered.buttons),
+            });
+            return;
+        }
+        const requestedAgent = parseAgentUpdateId(subcommand);
+        if (requestedAgent) {
+            await startTelegramAgentUpdate(ctx, requestedAgent);
+            return;
+        }
+        if (subcommand) {
+            const usage = "Unknown update target. Use /update, /update agents, /update jobs, /update <agent>, /update log <id>, /update cancel <id>, or /update input <id> <text>.";
+            await safeReply(ctx, escapeHTML(usage), { fallbackText: usage });
+            return;
+        }
         const update = spawnSelfUpdate();
-        const plain = [
-            "Update started.",
-            `Method: ${update.method}`,
-            update.summary,
-            `Source: ${update.sourceRoot}`,
-            `Log: ${update.logPath}`,
-            "Use /logs update after the restart or inspect update.log on the host.",
-        ].join("\n");
-        const html = [
-            "<b>Update started.</b>",
-            `<b>Method:</b> <code>${escapeHTML(update.method)}</code>`,
-            escapeHTML(update.summary),
-            `<b>Source:</b> <code>${escapeHTML(update.sourceRoot)}</code>`,
-            `<b>Log:</b> <code>${escapeHTML(update.logPath)}</code>`,
-            `Use <code>/logs update</code> after the restart or inspect <code>${escapeHTML(getUpdateLogPath())}</code> on the host.`,
-        ].join("\n");
-        await safeReply(ctx, html, { fallbackText: plain });
+        const rendered = renderSelfUpdateStartedAction(update);
+        await safeReply(ctx, rendered.html, { fallbackText: rendered.plain });
+    });
+    bot.callbackQuery("upd_jobs", async (ctx) => {
+        await ctx.answerCallbackQuery();
+        const rendered = renderAgentUpdateJobsAction(agentUpdates.list());
+        await safeReply(ctx, rendered.html, { fallbackText: rendered.plain });
+    });
+    bot.callbackQuery(/^upd_agent:(codex|pi|hermes|openclaw|claude-code)$/, async (ctx) => {
+        const agentId = ctx.match?.[1];
+        if (!agentId) {
+            await ctx.answerCallbackQuery();
+            return;
+        }
+        await ctx.answerCallbackQuery({ text: `Starting ${agentLabel(agentId)} update...` });
+        await startTelegramAgentUpdate(ctx, agentId);
+    });
+    bot.callbackQuery(/^upd_log:(.+)$/, async (ctx) => {
+        const id = ctx.match?.[1];
+        await ctx.answerCallbackQuery();
+        if (!id) {
+            return;
+        }
+        const rendered = renderAgentUpdateLogAction(agentUpdates.readLog(id));
+        await safeReply(ctx, rendered.html, { fallbackText: rendered.plain });
+    });
+    bot.callbackQuery(/^upd_cancel:(.+)$/, async (ctx) => {
+        const id = ctx.match?.[1];
+        await ctx.answerCallbackQuery({ text: "Cancelling update..." });
+        if (!id) {
+            return;
+        }
+        const job = agentUpdates.cancel(id);
+        const rendered = renderAgentUpdateJobAction(job);
+        await safeReply(ctx, rendered.html, {
+            fallbackText: rendered.plain,
+            replyMarkup: actionKeyboard(rendered.buttons),
+        });
     });
     bot.command("new", async (ctx) => {
         const chatId = ctx.chat?.id;
@@ -2230,8 +2407,14 @@ export function createBot(config, registry) {
         if (!contextSession) {
             return;
         }
-        const { session } = contextSession;
+        const { contextKey, session } = contextSession;
         try {
+            const busy = getBusyReason(contextKey);
+            if (busy.kind === "external") {
+                const text = `Cannot abort the external ${busy.activity.agentLabel} CLI task from NordRelay. Stop it in the terminal where it is running; queued Telegram messages will wait.`;
+                await safeReply(ctx, escapeHTML(text), { fallbackText: text });
+                return;
+            }
             await session.abort();
             await safeReply(ctx, escapeHTML("Aborted current operation"), {
                 fallbackText: "Aborted current operation",
@@ -2311,7 +2494,7 @@ export function createBot(config, registry) {
                 });
                 return;
             }
-            const rendered = renderQueuedPromptDetail(item);
+            const rendered = renderQueuedPromptDetailAction(item);
             await safeReply(ctx, rendered.html, { fallbackText: rendered.plain });
             return;
         }
@@ -2469,7 +2652,7 @@ export function createBot(config, registry) {
                     });
                     return;
                 }
-                const rendered = renderArtifactReports(filtered);
+                const rendered = renderArtifactReportsAction(filtered);
                 await safeReply(ctx, rendered.html, {
                     fallbackText: rendered.plain,
                     replyMarkup: buildArtifactActionsKeyboard(filtered),
@@ -2495,7 +2678,7 @@ export function createBot(config, registry) {
             }
             return;
         }
-        const { html, plain } = renderArtifactReports(reports);
+        const { html, plain } = renderArtifactReportsAction(reports);
         await safeReply(ctx, html, {
             fallbackText: plain,
             replyMarkup: buildArtifactActionsKeyboard(reports),
@@ -2536,28 +2719,29 @@ export function createBot(config, registry) {
             });
             return;
         }
-        const selectedLaunchProfile = session.getSelectedLaunchProfile();
-        const launchButtons = config.launchProfiles.map((profile, index) => ({
-            label: formatLaunchProfileLabel(profile, profile.id === selectedLaunchProfile.id),
+        const profiles = session.listLaunchProfiles();
+        const selectedLaunchProfile = session.getInfo();
+        const launchButtons = profiles.map((profile, index) => ({
+            label: formatAgentLaunchProfileLabel(profile, profile.id === selectedLaunchProfile.launchProfileId),
             callbackData: `launch_${index}`,
         }));
-        pendingLaunchPicks.set(contextKey, config.launchProfiles.map((profile) => profile.id));
+        pendingLaunchPicks.set(contextKey, profiles.map((profile) => profile.id));
         pendingLaunchButtons.set(contextKey, launchButtons);
         pendingUnsafeLaunchConfirmations.delete(contextKey);
         const keyboard = paginateKeyboard(launchButtons, 0, "launch");
         const htmlLines = [
-            `<b>Selected launch profile:</b> <code>${escapeHTML(selectedLaunchProfile.label)}</code>`,
-            `<b>Behavior:</b> <code>${escapeHTML(formatLaunchProfileBehavior(selectedLaunchProfile))}</code>`,
+            `<b>Selected launch profile:</b> <code>${escapeHTML(selectedLaunchProfile.launchProfileLabel)}</code>`,
+            `<b>Behavior:</b> <code>${escapeHTML(selectedLaunchProfile.launchProfileBehavior)}</code>`,
             "",
             "Select a profile for new or reattached threads:",
         ];
         const plainLines = [
-            `Selected launch profile: ${selectedLaunchProfile.label}`,
-            `Behavior: ${formatLaunchProfileBehavior(selectedLaunchProfile)}`,
+            `Selected launch profile: ${selectedLaunchProfile.launchProfileLabel}`,
+            `Behavior: ${selectedLaunchProfile.launchProfileBehavior}`,
             "",
             "Select a profile for new or reattached threads:",
         ];
-        if (selectedLaunchProfile.unsafe) {
+        if (selectedLaunchProfile.unsafeLaunch) {
             htmlLines.splice(2, 0, "⚠️ <i>Selected profile uses danger-full-access.</i>");
             plainLines.splice(2, 0, "⚠️ Selected profile uses danger-full-access.");
         }
@@ -2897,6 +3081,10 @@ export function createBot(config, registry) {
             });
             return;
         }
+        const info = session.getInfo();
+        await session.refreshModels({ force: true }).catch((error) => {
+            console.warn(`Failed to refresh ${labelOf(info)} models: ${error instanceof Error ? error.message : String(error)}`);
+        });
         const models = session.listModels();
         if (models.length === 0) {
             await safeReply(ctx, escapeHTML("No models available."), {
@@ -2906,7 +3094,7 @@ export function createBot(config, registry) {
         }
         const currentModel = session.getInfo().model ?? "(default)";
         const modelButtons = models.map((model) => ({
-            label: `${model.displayName}${model.slug === currentModel ? " ✓" : ""}`,
+            label: formatModelButtonLabel(model, model.slug === currentModel),
             callbackData: `model_${model.slug}`,
         }));
         pendingModelButtons.set(contextKey, modelButtons);
@@ -2993,7 +3181,7 @@ export function createBot(config, registry) {
             await safeReply(ctx, escapeHTML(text), { fallbackText: text });
             return;
         }
-        const efforts = idOf(info) === "pi" ? PI_THINKING_LEVELS : CODEX_REASONING_EFFORTS;
+        const efforts = agentReasoningOptions(idOf(info));
         const current = info.reasoningEffort;
         const effortButtons = efforts.map((effort) => ({
             label: effort === current ? `${effort} ✓` : effort,
@@ -3011,7 +3199,7 @@ export function createBot(config, registry) {
         });
     };
     bot.command(["effort", "reasoning"], openReasoningPicker);
-    bot.callbackQuery(/^agent_(codex|pi)$/, async (ctx) => {
+    bot.callbackQuery(/^agent_(codex|pi|hermes|openclaw|claude-code)$/, async (ctx) => {
         const chatId = ctx.chat?.id;
         const messageId = ctx.callbackQuery.message?.message_id;
         const selectedAgent = ctx.match?.[1];
@@ -3365,7 +3553,7 @@ export function createBot(config, registry) {
             await ctx.answerCallbackQuery({ text: "Wait for the current prompt to finish" });
             return;
         }
-        const profile = findLaunchProfile(config.launchProfiles, profileId);
+        const profile = session.listLaunchProfiles().find((candidate) => candidate.id === profileId);
         if (!profile) {
             clearLaunchSelectionState(contextKey);
             await ctx.answerCallbackQuery({ text: "Launch profile no longer exists" });
@@ -3382,14 +3570,14 @@ export function createBot(config, registry) {
                 .text("Cancel", `launchconfirm_no:${profile.id}`);
             const html = [
                 `<b>Confirm launch profile:</b> <code>${escapeHTML(profile.label)}</code>`,
-                `<b>Behavior:</b> <code>${escapeHTML(formatLaunchProfileBehavior(profile))}</code>`,
+                `<b>Behavior:</b> <code>${escapeHTML(profile.behavior)}</code>`,
                 "",
                 "⚠️ <b>This profile uses danger-full-access.</b>",
                 "It will apply to new or reattached threads in this Telegram context.",
             ].join("\n");
             const plain = [
                 `Confirm launch profile: ${profile.label}`,
-                `Behavior: ${formatLaunchProfileBehavior(profile)}`,
+                `Behavior: ${profile.behavior}`,
                 "",
                 "WARNING: This profile uses danger-full-access.",
                 "It will apply to new or reattached threads in this Telegram context.",
@@ -3410,17 +3598,18 @@ export function createBot(config, registry) {
         }
         await ctx.answerCallbackQuery({ text: `Launch set to ${profile.label}` });
         clearLaunchSelectionState(contextKey);
-        const selectedProfile = session.setLaunchProfile(profile.id);
+        session.setLaunchProfile(profile.id);
         updateSessionMetadata(contextKey, session);
+        const info = session.getInfo();
         const html = [
-            `<b>Launch profile set to</b> <code>${escapeHTML(selectedProfile.label)}</code>`,
-            `<b>Behavior:</b> <code>${escapeHTML(formatLaunchProfileBehavior(selectedProfile))}</code>`,
+            `<b>Launch profile set to</b> <code>${escapeHTML(info.launchProfileLabel)}</code>`,
+            `<b>Behavior:</b> <code>${escapeHTML(info.launchProfileBehavior)}</code>`,
             "",
             "Applies to new or reattached threads.",
         ].join("\n");
         const plain = [
-            `Launch profile set to ${selectedProfile.label}`,
-            `Behavior: ${formatLaunchProfileBehavior(selectedProfile)}`,
+            `Launch profile set to ${info.launchProfileLabel}`,
+            `Behavior: ${info.launchProfileBehavior}`,
             "",
             "Applies to new or reattached threads.",
         ].join("\n");
@@ -3461,7 +3650,7 @@ export function createBot(config, registry) {
             await ctx.answerCallbackQuery({ text: "Wait for the current prompt to finish" });
             return;
         }
-        const profile = findLaunchProfile(config.launchProfiles, profileId);
+        const profile = session.listLaunchProfiles().find((candidate) => candidate.id === profileId);
         if (!profile) {
             clearLaunchSelectionState(contextKey);
             await ctx.answerCallbackQuery({ text: "Launch profile no longer exists" });
@@ -3471,18 +3660,19 @@ export function createBot(config, registry) {
             return;
         }
         clearLaunchSelectionState(contextKey);
-        const selectedProfile = session.setLaunchProfile(profile.id);
+        session.setLaunchProfile(profile.id);
         updateSessionMetadata(contextKey, session);
-        await ctx.answerCallbackQuery({ text: `Launch set to ${selectedProfile.label}` });
+        const info = session.getInfo();
+        await ctx.answerCallbackQuery({ text: `Launch set to ${info.launchProfileLabel}` });
         const html = [
-            `<b>Launch profile set to</b> <code>${escapeHTML(selectedProfile.label)}</code>`,
-            `<b>Behavior:</b> <code>${escapeHTML(formatLaunchProfileBehavior(selectedProfile))}</code>`,
+            `<b>Launch profile set to</b> <code>${escapeHTML(info.launchProfileLabel)}</code>`,
+            `<b>Behavior:</b> <code>${escapeHTML(info.launchProfileBehavior)}</code>`,
             "",
             "⚠️ <i>danger-full-access confirmed for new or reattached threads.</i>",
         ].join("\n");
         const plain = [
-            `Launch profile set to ${selectedProfile.label}`,
-            `Behavior: ${formatLaunchProfileBehavior(selectedProfile)}`,
+            `Launch profile set to ${info.launchProfileLabel}`,
+            `Behavior: ${info.launchProfileBehavior}`,
             "",
             "danger-full-access confirmed for new or reattached threads.",
         ].join("\n");
@@ -3519,9 +3709,7 @@ export function createBot(config, registry) {
         try {
             const result = await session.setModelForCurrentSession(slug);
             updateSessionMetadata(contextKey, session);
-            const scope = result.appliedToActiveThread
-                ? "applied to the current idle thread and future threads"
-                : "applies to new threads";
+            const scope = formatAgentSettingScope(session.getInfo(), result.appliedToActiveThread);
             const html = `<b>Model set to</b> <code>${escapeHTML(result.value)}</code> — ${escapeHTML(scope)}.`;
             const plainText = `Model set to ${result.value} — ${scope}.`;
             if (messageId) {
@@ -3542,7 +3730,7 @@ export function createBot(config, registry) {
             }
         }
     });
-    bot.callbackQuery(/^effort_(off|minimal|low|medium|high|xhigh)$/, async (ctx) => {
+    bot.callbackQuery(/^effort_(off|none|minimal|low|medium|high|xhigh)$/, async (ctx) => {
         const chatId = ctx.chat?.id;
         const messageId = ctx.callbackQuery.message?.message_id;
         const effort = ctx.match?.[1];
@@ -3568,9 +3756,7 @@ export function createBot(config, registry) {
         const result = await session.setReasoningEffortForCurrentSession(effort);
         updateSessionMetadata(contextKey, session);
         const label = agentReasoningLabel(idOf(session.getInfo()));
-        const scope = result.appliedToActiveThread
-            ? "applied to the current idle thread and future threads"
-            : "applies to new threads";
+        const scope = formatAgentSettingScope(session.getInfo(), result.appliedToActiveThread);
         const html = `⚡ ${escapeHTML(label)} set to <code>${escapeHTML(effort)}</code> — ${escapeHTML(scope)}.`;
         await safeEditMessage(bot, chatId, messageId, html, {
             fallbackText: `⚡ ${label} set to ${effort} — ${scope}.`,
@@ -3901,7 +4087,7 @@ export async function registerCommands(bot) {
         { command: "help", description: "Command reference" },
         { command: "channels", description: "Messaging adapter status" },
         { command: "agents", description: "Agent adapter status" },
-        { command: "agent", description: "Select Codex or Pi" },
+        { command: "agent", description: "Select agent" },
         { command: "new", description: "Start a new thread" },
         { command: "session", description: "Current thread details" },
         { command: "sessions", description: "Browse & switch threads" },
@@ -3940,23 +4126,12 @@ export async function registerCommands(bot) {
         { command: "unlock", description: "Release session write lock" },
         { command: "locks", description: "List session write locks" },
         { command: "restart", description: "Admin: restart connector" },
-        { command: "update", description: "Admin: update connector" },
+        { command: "update", description: "Admin: update connector or agents" },
         { command: "handback", description: "Hand session back to CLI" },
         { command: "attach", description: "Bind a session to this topic" },
         { command: "switch", description: "Switch to a thread by ID" },
     ]);
 }
-function renderArtifactReports(reports) {
-    const lines = reports.slice(0, 5).map((report, index) => {
-        const size = formatFileSize(totalArtifactSize(report.artifacts));
-        const skipped = report.skippedCount > 0 ? `, ${report.skippedCount} skipped` : "";
-        return `${index + 1}. ${report.turnId} · ${formatRelativeTime(report.updatedAt)} · ${report.artifacts.length} file${report.artifacts.length === 1 ? "" : "s"} · ${size}${skipped}`;
-    });
-    const usage = "Tap an action below, or use /artifacts latest, /artifacts zip latest, /artifacts images, /artifacts docs, /artifacts search <text>, or /artifacts delete <turn-id>.";
-    const plain = ["Recent artifacts:", ...lines, "", usage].join("\n");
-    const html = ["<b>Recent artifacts:</b>", ...lines.map(escapeHTML), "", escapeHTML(usage)].join("\n");
-    return { html, plain };
-}
 function renderVersionCheckPlain(check) {
     const icon = versionStatusIcon(check);
     const label = check.label === "NordRelay" ? "NordRelay" : `${check.label} version`;
@@ -4002,73 +4177,6 @@ function formatVersionCheckDetailHTML(check) {
 function versionStatusIcon(check) {
     return check.status === "current" ? "✅" : "⚠️";
 }
-function parseLogsCommand(argument) {
-    const tokens = argument.split(/\s+/).filter(Boolean);
-    let target = "connector";
-    let lines = 80;
-    for (const token of tokens) {
-        const normalized = token.toLowerCase();
-        if (normalized === "connector" || normalized === "main") {
-            target = "connector";
-            continue;
-        }
-        if (normalized === "update" || normalized === "updates") {
-            target = "update";
-            continue;
-        }
-        if (normalized === "all") {
-            target = "all";
-            continue;
-        }
-        const parsedLines = Number.parseInt(token, 10);
-        if (!Number.isNaN(parsedLines)) {
-            lines = parsedLines;
-        }
-    }
-    return { target, lines };
-}
-function renderLogTailPlain(title, tail) {
-    return [
-        `${title} log tail`,
-        `File: ${tail.filePath}`,
-        `Updated: ${tail.updatedAt ? formatLogDate(tail.updatedAt) : "-"}`,
-        `Lines: ${tail.lineCount}/${tail.requestedLines}`,
-        "",
-        tail.plain || "(empty)",
-    ].join("\n");
-}
-function renderLogTailHTML(title, tail) {
-    const body = tail.plain
-        ? tail.plain.split("\n").map(renderLogLineHTML).join("\n")
-        : "<code>(empty)</code>";
-    return [
-        `<b>${escapeHTML(title)} log tail</b>`,
-        `<b>File:</b> <code>${escapeHTML(tail.filePath)}</code>`,
-        `<b>Updated:</b> <code>${escapeHTML(tail.updatedAt ? formatLogDate(tail.updatedAt) : "-")}</code>`,
-        `<b>Lines:</b> <code>${tail.lineCount}/${tail.requestedLines}</code>`,
-        "",
-        body,
-    ].join("\n");
-}
-function formatLogDate(date) {
-    return [
-        `${date.getFullYear()}-${pad2(date.getMonth() + 1)}-${pad2(date.getDate())}`,
-        `${pad2(date.getHours())}:${pad2(date.getMinutes())}:${pad2(date.getSeconds())}`,
-    ].join(" ");
-}
-function renderLogLineHTML(line) {
-    const structured = line.match(/^(?<timestamp>\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}|unknown time\s*)\s+(?<level>INFO|WARN|ERROR)\s+(?<message>.*)$/);
-    if (structured?.groups) {
-        const level = structured.groups.level;
-        const levelHtml = level === "INFO" ? escapeHTML(level) : `<b>${escapeHTML(level)}</b>`;
-        return [
-            `<code>${escapeHTML(structured.groups.timestamp.trim())}</code>`,
-            levelHtml,
-            escapeHTML(structured.groups.message),
-        ].join(" ");
-    }
-    return escapeHTML(line);
-}
 function renderAuditEvents(events) {
     if (events.length === 0) {
         return {
@@ -4108,29 +4216,6 @@ function renderSessionLocks(locks) {
         html: ["<b>Session locks:</b>", ...lines.map((line) => escapeHTML(line))].join("\n"),
     };
 }
-function renderQueuedPromptDetail(item) {
-    const lines = [
-        "Queued prompt:",
-        `ID: ${item.id}`,
-        `Created: ${formatLocalDateTime(new Date(item.createdAt))}`,
-        item.notBefore ? `Scheduled: ${formatLocalDateTime(new Date(item.notBefore))}` : undefined,
-        `Attempts: ${item.attempts ?? 0}`,
-        item.lastError ? `Last error: ${item.lastError}` : undefined,
-        `Description: ${item.description}`,
-    ].filter((line) => Boolean(line));
-    return {
-        plain: lines.join("\n"),
-        html: [
-            "<b>Queued prompt:</b>",
-            `<b>ID:</b> <code>${escapeHTML(item.id)}</code>`,
-            `<b>Created:</b> <code>${escapeHTML(formatLocalDateTime(new Date(item.createdAt)))}</code>`,
-            item.notBefore ? `<b>Scheduled:</b> <code>${escapeHTML(formatLocalDateTime(new Date(item.notBefore)))}</code>` : undefined,
-            `<b>Attempts:</b> <code>${item.attempts ?? 0}</code>`,
-            item.lastError ? `<b>Last error:</b> ${escapeHTML(item.lastError)}` : undefined,
-            `<b>Description:</b> ${escapeHTML(item.description)}`,
-        ].filter((line) => Boolean(line)).join("\n"),
-    };
-}
 function formatLockOwner(lock) {
     if (!lock) {
         return "nobody";
@@ -4259,7 +4344,7 @@ function renderExternalMirrorStatus(snapshot, queueLength) {
         ? formatDurationSeconds((Date.now() - snapshot.activity.startedAt.getTime()) / 1000)
         : "-";
     const lines = [
-        "Codex CLI task running.",
+        `${snapshot.agentLabel} CLI task running.`,
         `Thread: ${snapshot.threadId}`,
         `Elapsed: ${elapsed}`,
         `Prompt: ${prompt}`,
@@ -4269,7 +4354,7 @@ function renderExternalMirrorStatus(snapshot, queueLength) {
     return {
         plain: lines.join("\n"),
         html: [
-            "<b>Codex CLI task running.</b>",
+            `<b>${escapeHTML(snapshot.agentLabel)} CLI task running.</b>`,
             `<b>Thread:</b> <code>${escapeHTML(snapshot.threadId)}</code>`,
             `<b>Elapsed:</b> <code>${escapeHTML(elapsed)}</code>`,
             `<b>Prompt:</b> <code>${escapeHTML(prompt)}</code>`,
@@ -4302,8 +4387,8 @@ function renderExternalMirrorEvent(event) {
 function renderActivityTimeline(threadId, events, options = { limit: 16, filter: "all", exportFile: false }) {
     if (events.length === 0) {
         return {
-            plain: `Activity:\nThread: ${threadId}\nFilter: ${options.filter}\nNo rollout events found.`,
-            html: `<b>Activity:</b>\n<b>Thread:</b> <code>${escapeHTML(threadId)}</code>\n<b>Filter:</b> <code>${escapeHTML(options.filter)}</code>\n<code>No rollout events found.</code>`,
+            plain: `Activity:\nThread: ${threadId}\nFilter: ${options.filter}\nNo activity events found.`,
+            html: `<b>Activity:</b>\n<b>Thread:</b> <code>${escapeHTML(threadId)}</code>\n<b>Filter:</b> <code>${escapeHTML(options.filter)}</code>\n<code>No activity events found.</code>`,
         };
     }
     const lines = events.map((event) => {
@@ -4379,50 +4464,36 @@ function filterActivityEvents(events, options) {
 function isActivityFilter(value) {
     return value === "all" || value === "tools" || value === "errors" || value === "user" || value === "agent" || value === "tasks";
 }
-function renderRolloutDiagnostics(threadId, staleAfterMs) {
-    if (!threadId) {
-        return {
-            plain: "Rollout: no active thread",
-            html: "<b>Rollout:</b> <code>no active thread</code>",
-        };
-    }
-    const snapshot = getThreadRolloutSnapshot(threadId, { staleAfterMs, maxEvents: 0 });
-    if (!snapshot) {
-        return {
-            plain: `Rollout:\nThread: ${threadId}\nStatus: unavailable`,
-            html: [
-                "<b>Rollout:</b>",
-                `<b>Thread:</b> <code>${escapeHTML(threadId)}</code>`,
-                "<b>Status:</b> <code>unavailable</code>",
-            ].join("\n"),
-        };
-    }
-    const activity = snapshot.activity;
-    const status = activity.active ? "active" : activity.stale ? "stale" : "idle";
-    const reason = activity.active
-        ? "open task without terminal event"
-        : activity.stale
-            ? "open task exceeded stale timeout"
-            : "no open task";
-    const lines = [
-        "Rollout:",
-        `Path: ${snapshot.rolloutPath}`,
-        `Status: ${status}`,
-        `Reason: ${reason}`,
-        `Turn: ${activity.turnId ?? "-"}`,
-        `Lines: ${snapshot.lineCount}`,
-        `Updated: ${activity.updatedAt?.toISOString() ?? "-"}`,
-    ];
+function formatAgentLaunchProfileLabel(profile, selected) {
+    const prefix = selected ? "✅" : profile.unsafe ? "⚠️" : "🚀";
+    return `${prefix} ${profile.label} · ${trimLine(profile.behavior, 24)}`;
+}
+function formatModelButtonLabel(model, selected) {
+    const meta = [
+        model.contextWindow ? formatCompactNumber(model.contextWindow) : undefined,
+        model.supportsImages === true ? "img" : model.supportsImages === false ? "text" : undefined,
+        model.supportsThinking === true ? "think" : undefined,
+    ].filter(Boolean).join(" ");
+    return trimLine(`${selected ? "✅ " : ""}${model.displayName}${meta ? ` · ${meta}` : ""}`, 58);
+}
+function formatCompactNumber(value) {
+    if (value >= 1_000_000_000)
+        return `${Math.round(value / 100_000_000) / 10}B`;
+    if (value >= 1_000_000)
+        return `${Math.round(value / 100_000) / 10}M`;
+    if (value >= 1_000)
+        return `${Math.round(value / 100) / 10}K`;
+    return String(value);
+}
+function renderAgentDiagnostics(diagnostics) {
     return {
-        plain: lines.join("\n"),
+        plain: [
+            `${diagnostics.agentLabel} state:`,
+            ...diagnostics.lines.map((line) => `${line.label}: ${line.value}`),
+        ].join("\n"),
         html: [
-            "<b>Rollout:</b>",
-            `<b>Path:</b> <code>${escapeHTML(snapshot.rolloutPath)}</code>`,
-            `<b>Status:</b> <code>${escapeHTML(status)}</code>`,
-            `<b>Reason:</b> <code>${escapeHTML(reason)}</code>`,
-            `<b>Turn:</b> <code>${escapeHTML(activity.turnId ?? "-")}</code>`,
-            `<b>Lines:</b> <code>${snapshot.lineCount}</code>`,
-            `<b>Updated:</b> <code>${escapeHTML(activity.updatedAt?.toISOString() ?? "-")}</code>`,
+            `<b>${escapeHTML(diagnostics.agentLabel)} state:</b>`,
+            ...diagnostics.lines.map((line) => `<b>${escapeHTML(line.label)}:</b> <code>${escapeHTML(line.value)}</code>`),
         ].join("\n"),
     };
 }
@@ -4462,6 +4533,11 @@ function renderDiagnosticsPlain(config, registry, health, authenticated, role, q
         `Telegram transport: ${config.telegramTransport}`,
         `Codex CLI: ${health.codexCli}`,
         `Pi CLI: ${health.piCli}`,
+        `Hermes CLI: ${health.hermesCli}`,
+        `OpenClaw CLI: ${health.openClawCli}`,
+        `Claude Code CLI: ${health.claudeCodeCli}`,
+        `Hermes API: ${config.hermesApiBaseUrl}`,
+        `OpenClaw Gateway: ${config.openClawGatewayUrl}`,
         `Enabled agents/default: ${enabledAgents(config).join(", ")} / ${config.defaultAgent}`,
         `State DB: ${health.databasePath ?? "-"}`,
         `Log file: ${health.logFile}`,
@@ -4502,6 +4578,11 @@ function renderDiagnosticsHTML(config, registry, health, authenticated, role, qu
         `<b>Telegram transport:</b> <code>${escapeHTML(config.telegramTransport)}</code>`,
         `<b>Codex CLI:</b> <code>${escapeHTML(health.codexCli)}</code>`,
         `<b>Pi CLI:</b> <code>${escapeHTML(health.piCli)}</code>`,
+        `<b>Hermes CLI:</b> <code>${escapeHTML(health.hermesCli)}</code>`,
+        `<b>OpenClaw CLI:</b> <code>${escapeHTML(health.openClawCli)}</code>`,
+        `<b>Claude Code CLI:</b> <code>${escapeHTML(health.claudeCodeCli)}</code>`,
+        `<b>Hermes API:</b> <code>${escapeHTML(config.hermesApiBaseUrl)}</code>`,
+        `<b>OpenClaw Gateway:</b> <code>${escapeHTML(config.openClawGatewayUrl)}</code>`,
         `<b>Enabled agents/default:</b> <code>${escapeHTML(`${enabledAgents(config).join(", ")} / ${config.defaultAgent}`)}</code>`,
         `<b>State DB:</b> <code>${escapeHTML(health.databasePath ?? "-")}</code>`,
         `<b>Log file:</b> <code>${escapeHTML(health.logFile)}</code>`,
@@ -4539,6 +4620,9 @@ function renderHealthPlain(health, authenticated, role) {
         `Workspace: ${health.state.workspace ?? "-"}`,
         `Codex CLI: ${health.codexCli}`,
         `Pi CLI: ${health.piCli}`,
+        `Hermes CLI: ${health.hermesCli}`,
+        `OpenClaw CLI: ${health.openClawCli}`,
+        `Claude Code CLI: ${health.claudeCodeCli}`,
         `Codex state DB: ${health.databasePath ?? "-"}`,
         `Log: ${health.logFile}`,
     ].join("\n");
@@ -4555,6 +4639,9 @@ function renderHealthHTML(health, authenticated, role) {
         `<b>Workspace:</b> <code>${escapeHTML(health.state.workspace ?? "-")}</code>`,
         `<b>Codex CLI:</b> <code>${escapeHTML(health.codexCli)}</code>`,
         `<b>Pi CLI:</b> <code>${escapeHTML(health.piCli)}</code>`,
+        `<b>Hermes CLI:</b> <code>${escapeHTML(health.hermesCli)}</code>`,
+        `<b>OpenClaw CLI:</b> <code>${escapeHTML(health.openClawCli)}</code>`,
+        `<b>Claude Code CLI:</b> <code>${escapeHTML(health.claudeCodeCli)}</code>`,
         `<b>Codex state DB:</b> <code>${escapeHTML(health.databasePath ?? "-")}</code>`,
         `<b>Log:</b> <code>${escapeHTML(health.logFile)}</code>`,
     ].join("\n");
@@ -4622,6 +4709,48 @@ function labelOf(info) {
 function idOf(info) {
     return info.agentId ?? "codex";
 }
+function authHelpText(info) {
+    const agentId = idOf(info);
+    if (agentId === "pi") {
+        return "Configure the required Pi provider environment variable on the host.";
+    }
+    if (agentId === "hermes") {
+        return "Start the Hermes API Server, configure HERMES_API_KEY when required, or use /login to start Hermes CLI auth.";
+    }
+    if (agentId === "openclaw") {
+        return "Start the OpenClaw Gateway and configure OPENCLAW_GATEWAY_TOKEN or OPENCLAW_GATEWAY_PASSWORD when the gateway requires one.";
+    }
+    if (agentId === "claude-code") {
+        return "Use /login to start Claude Code CLI auth, or run 'claude auth login' on the host.";
+    }
+    return "Use /login to start authentication, or set CODEX_API_KEY on the host.";
+}
+function formatAgentSettingScope(info, appliedToActiveThread) {
+    const agentId = idOf(info);
+    if (agentId === "hermes") {
+        return appliedToActiveThread
+            ? "applies to the next Hermes run in this session"
+            : "applies to new Hermes sessions";
+    }
+    if (agentId === "pi") {
+        return appliedToActiveThread
+            ? "applied to the current idle Pi session and future turns"
+            : "applies to new Pi sessions";
+    }
+    if (agentId === "openclaw") {
+        return appliedToActiveThread
+            ? "applies to the next OpenClaw run in this session"
+            : "applies to new OpenClaw sessions";
+    }
+    if (agentId === "claude-code") {
+        return appliedToActiveThread
+            ? "applies to the next Claude Code run in this session"
+            : "applies to new Claude Code sessions";
+    }
+    return appliedToActiveThread
+        ? "applied to the current idle thread and future threads"
+        : "applies to new threads";
+}
 function requiresTurnApproval(info) {
     return info.unsafeLaunch || info.approvalPolicy !== "never";
 }